Back to index...

	/*
	* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code 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
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package javax.swing;


	import javax.swing.border.*;

	import java.awt.LayoutManager;
	import java.awt.Component;
	import java.awt.Container;
	import java.awt.Rectangle;
	import java.awt.Dimension;
	import java.awt.Insets;
	import java.io.Serializable;


	/**
	* The layout manager used by <code>JScrollPane</code>.
	* <code>JScrollPaneLayout</code> is
	* responsible for nine components: a viewport, two scrollbars,
	* a row header, a column header, and four "corner" components.
	* <p>
	* <strong>Warning:</strong>
	* 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™
	* has been added to the <code>java.beans</code> package.
	* Please see {@link java.beans.XMLEncoder}.
	*
	* @see JScrollPane
	* @see JViewport
	*
	* @author Hans Muller
	*/
	public class ScrollPaneLayout
	implements LayoutManager, ScrollPaneConstants, Serializable
	{

	/**
	* The scrollpane's viewport child.
	* Default is an empty <code>JViewport</code>.
	* @see JScrollPane#setViewport
	*/
	protected JViewport viewport;


	/**
	* The scrollpane's vertical scrollbar child.
	* Default is a <code>JScrollBar</code>.
	* @see JScrollPane#setVerticalScrollBar
	*/
	protected JScrollBar vsb;


	/**
	* The scrollpane's horizontal scrollbar child.
	* Default is a <code>JScrollBar</code>.
	* @see JScrollPane#setHorizontalScrollBar
	*/
	protected JScrollBar hsb;


	/**
	* The row header child. Default is <code>null</code>.
	* @see JScrollPane#setRowHeader
	*/
	protected JViewport rowHead;


	/**
	* The column header child. Default is <code>null</code>.
	* @see JScrollPane#setColumnHeader
	*/
	protected JViewport colHead;


	/**
	* The component to display in the lower left corner.
	* Default is <code>null</code>.
	* @see JScrollPane#setCorner
	*/
	protected Component lowerLeft;


	/**
	* The component to display in the lower right corner.
	* Default is <code>null</code>.
	* @see JScrollPane#setCorner
	*/
	protected Component lowerRight;


	/**
	* The component to display in the upper left corner.
	* Default is <code>null</code>.
	* @see JScrollPane#setCorner
	*/
	protected Component upperLeft;


	/**
	* The component to display in the upper right corner.
	* Default is <code>null</code>.
	* @see JScrollPane#setCorner
	*/
	protected Component upperRight;


	/**
	* The display policy for the vertical scrollbar.
	* The default is <code>ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED</code>.
	* <p>
	* This field is obsolete, please use the <code>JScrollPane</code> field instead.
	*
	* @see JScrollPane#setVerticalScrollBarPolicy
	*/
	protected int vsbPolicy = VERTICAL_SCROLLBAR_AS_NEEDED;


	/**
	* The display policy for the horizontal scrollbar.
	* The default is <code>ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED</code>.
	* <p>
	* This field is obsolete, please use the <code>JScrollPane</code> field instead.
	*
	* @see JScrollPane#setHorizontalScrollBarPolicy
	*/
	protected int hsbPolicy = HORIZONTAL_SCROLLBAR_AS_NEEDED;


	/**
	* This method is invoked after the ScrollPaneLayout is set as the
	* LayoutManager of a <code>JScrollPane</code>.
	* It initializes all of the internal fields that
	* are ordinarily set by <code>addLayoutComponent</code>. For example:
	* <pre>
	* ScrollPaneLayout mySPLayout = new ScrollPanelLayout() {
	* public void layoutContainer(Container p) {
	* super.layoutContainer(p);
	* // do some extra work here ...
	* }
	* };
	* scrollpane.setLayout(mySPLayout):
	* </pre>
	*/
	public void syncWithScrollPane(JScrollPane sp) {
	viewport = sp.getViewport();
	vsb = sp.getVerticalScrollBar();
	hsb = sp.getHorizontalScrollBar();
	rowHead = sp.getRowHeader();
	colHead = sp.getColumnHeader();
	lowerLeft = sp.getCorner(LOWER_LEFT_CORNER);
	lowerRight = sp.getCorner(LOWER_RIGHT_CORNER);
	upperLeft = sp.getCorner(UPPER_LEFT_CORNER);
	upperRight = sp.getCorner(UPPER_RIGHT_CORNER);
	vsbPolicy = sp.getVerticalScrollBarPolicy();
	hsbPolicy = sp.getHorizontalScrollBarPolicy();
	}


	/**
	* Removes an existing component. When a new component, such as
	* the left corner, or vertical scrollbar, is added, the old one,
	* if it exists, must be removed.
	* <p>
	* This method returns <code>newC</code>. If <code>oldC</code> is
	* not equal to <code>newC</code> and is non-<code>null</code>,
	* it will be removed from its parent.
	*
	* @param oldC the <code>Component</code> to replace
	* @param newC the <code>Component</code> to add
	* @return the <code>newC</code>
	*/
	protected Component addSingletonComponent(Component oldC, Component newC)
	{
	if ((oldC != null) && (oldC != newC)) {
	oldC.getParent().remove(oldC);
	}
	return newC;
	}


	/**
	* Adds the specified component to the layout. The layout is
	* identified using one of:
	* <ul>
	* <li>ScrollPaneConstants.VIEWPORT
	* <li>ScrollPaneConstants.VERTICAL_SCROLLBAR
	* <li>ScrollPaneConstants.HORIZONTAL_SCROLLBAR
	* <li>ScrollPaneConstants.ROW_HEADER
	* <li>ScrollPaneConstants.COLUMN_HEADER
	* <li>ScrollPaneConstants.LOWER_LEFT_CORNER
	* <li>ScrollPaneConstants.LOWER_RIGHT_CORNER
	* <li>ScrollPaneConstants.UPPER_LEFT_CORNER
	* <li>ScrollPaneConstants.UPPER_RIGHT_CORNER
	* </ul>
	*
	* @param s the component identifier
	* @param c the the component to be added
	* @exception IllegalArgumentException if <code>s</code> is an invalid key
	*/
	public void addLayoutComponent(String s, Component c)
	{
	if (s.equals(VIEWPORT)) {
	viewport = (JViewport)addSingletonComponent(viewport, c);
	}
	else if (s.equals(VERTICAL_SCROLLBAR)) {
	vsb = (JScrollBar)addSingletonComponent(vsb, c);
	}
	else if (s.equals(HORIZONTAL_SCROLLBAR)) {
	hsb = (JScrollBar)addSingletonComponent(hsb, c);
	}
	else if (s.equals(ROW_HEADER)) {
	rowHead = (JViewport)addSingletonComponent(rowHead, c);
	}
	else if (s.equals(COLUMN_HEADER)) {
	colHead = (JViewport)addSingletonComponent(colHead, c);
	}
	else if (s.equals(LOWER_LEFT_CORNER)) {
	lowerLeft = addSingletonComponent(lowerLeft, c);
	}
	else if (s.equals(LOWER_RIGHT_CORNER)) {
	lowerRight = addSingletonComponent(lowerRight, c);
	}
	else if (s.equals(UPPER_LEFT_CORNER)) {
	upperLeft = addSingletonComponent(upperLeft, c);
	}
	else if (s.equals(UPPER_RIGHT_CORNER)) {
	upperRight = addSingletonComponent(upperRight, c);
	}
	else {
	throw new IllegalArgumentException("invalid layout key " + s);
	}
	}


	/**
	* Removes the specified component from the layout.
	*
	* @param c the component to remove
	*/
	public void removeLayoutComponent(Component c)
	{
	if (c == viewport) {
	viewport = null;
	}
	else if (c == vsb) {
	vsb = null;
	}
	else if (c == hsb) {
	hsb = null;
	}
	else if (c == rowHead) {
	rowHead = null;
	}
	else if (c == colHead) {
	colHead = null;
	}
	else if (c == lowerLeft) {
	lowerLeft = null;
	}
	else if (c == lowerRight) {
	lowerRight = null;
	}
	else if (c == upperLeft) {
	upperLeft = null;
	}
	else if (c == upperRight) {
	upperRight = null;
	}
	}


	/**
	* Returns the vertical scrollbar-display policy.
	*
	* @return an integer giving the display policy
	* @see #setVerticalScrollBarPolicy
	*/
	public int getVerticalScrollBarPolicy() {
	return vsbPolicy;
	}


	/**
	* Sets the vertical scrollbar-display policy. The options
	* are:
	* <ul>
	* <li>ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED
	* <li>ScrollPaneConstants.VERTICAL_SCROLLBAR_NEVER
	* <li>ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS
	* </ul>
	* Note: Applications should use the <code>JScrollPane</code> version
	* of this method. It only exists for backwards compatibility
	* with the Swing 1.0.2 (and earlier) versions of this class.
	*
	* @param x an integer giving the display policy
	* @exception IllegalArgumentException if <code>x</code> is an invalid
	* vertical scroll bar policy, as listed above
	*/
	public void setVerticalScrollBarPolicy(int x) {
	switch (x) {
	case VERTICAL_SCROLLBAR_AS_NEEDED:
	case VERTICAL_SCROLLBAR_NEVER:
	case VERTICAL_SCROLLBAR_ALWAYS:
	vsbPolicy = x;
	break;
	default:
	throw new IllegalArgumentException("invalid verticalScrollBarPolicy");
	}
	}


	/**
	* Returns the horizontal scrollbar-display policy.
	*
	* @return an integer giving the display policy
	* @see #setHorizontalScrollBarPolicy
	*/
	public int getHorizontalScrollBarPolicy() {
	return hsbPolicy;
	}

	/**
	* Sets the horizontal scrollbar-display policy.
	* The options are:<ul>
	* <li>ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED
	* <li>ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER
	* <li>ScrollPaneConstants.HORIZONTAL_SCROLLBAR_ALWAYS
	* </ul>
	* Note: Applications should use the <code>JScrollPane</code> version
	* of this method. It only exists for backwards compatibility
	* with the Swing 1.0.2 (and earlier) versions of this class.
	*
	* @param x an int giving the display policy
	* @exception IllegalArgumentException if <code>x</code> is not a valid
	* horizontal scrollbar policy, as listed above
	*/
	public void setHorizontalScrollBarPolicy(int x) {
	switch (x) {
	case HORIZONTAL_SCROLLBAR_AS_NEEDED:
	case HORIZONTAL_SCROLLBAR_NEVER:
	case HORIZONTAL_SCROLLBAR_ALWAYS:
	hsbPolicy = x;
	break;
	default:
	throw new IllegalArgumentException("invalid horizontalScrollBarPolicy");
	}
	}


	/**
	* Returns the <code>JViewport</code> object that displays the
	* scrollable contents.
	* @return the <code>JViewport</code> object that displays the scrollable contents
	* @see JScrollPane#getViewport
	*/
	public JViewport getViewport() {
	return viewport;
	}


	/**
	* Returns the <code>JScrollBar</code> object that handles horizontal scrolling.
	* @return the <code>JScrollBar</code> object that handles horizontal scrolling
	* @see JScrollPane#getHorizontalScrollBar
	*/
	public JScrollBar getHorizontalScrollBar() {
	return hsb;
	}

	/**
	* Returns the <code>JScrollBar</code> object that handles vertical scrolling.
	* @return the <code>JScrollBar</code> object that handles vertical scrolling
	* @see JScrollPane#getVerticalScrollBar
	*/
	public JScrollBar getVerticalScrollBar() {
	return vsb;
	}


	/**
	* Returns the <code>JViewport</code> object that is the row header.
	* @return the <code>JViewport</code> object that is the row header
	* @see JScrollPane#getRowHeader
	*/
	public JViewport getRowHeader() {
	return rowHead;
	}


	/**
	* Returns the <code>JViewport</code> object that is the column header.
	* @return the <code>JViewport</code> object that is the column header
	* @see JScrollPane#getColumnHeader
	*/
	public JViewport getColumnHeader() {
	return colHead;
	}


	/**
	* Returns the <code>Component</code> at the specified corner.
	* @param key the <code>String</code> specifying the corner
	* @return the <code>Component</code> at the specified corner, as defined in
	* {@link ScrollPaneConstants}; if <code>key</code> is not one of the
	* four corners, <code>null</code> is returned
	* @see JScrollPane#getCorner
	*/
	public Component getCorner(String key) {
	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;
	}
	}


	/**
	* The preferred size of a <code>ScrollPane</code> is the size of the insets,
	* plus the preferred size of the viewport, plus the preferred size of
	* the visible headers, plus the preferred size of the scrollbars
	* that will appear given the current view and the current
	* scrollbar displayPolicies.
	* <p>Note that the rowHeader is calculated as part of the preferred width
	* and the colHeader is calculated as part of the preferred size.
	*
	* @param parent the <code>Container</code> that will be laid out
	* @return a <code>Dimension</code> object specifying the preferred size of the
	* viewport and any scrollbars
	* @see ViewportLayout
	* @see LayoutManager
	*/
	public Dimension preferredLayoutSize(Container parent)
	{
	/* Sync the (now obsolete) policy fields with the
	* JScrollPane.
	*/
	JScrollPane scrollPane = (JScrollPane)parent;
	vsbPolicy = scrollPane.getVerticalScrollBarPolicy();
	hsbPolicy = scrollPane.getHorizontalScrollBarPolicy();

	Insets insets = parent.getInsets();
	int prefWidth = insets.left + insets.right;
	int prefHeight = insets.top + insets.bottom;

	/* Note that viewport.getViewSize() is equivalent to
	* viewport.getView().getPreferredSize() modulo a null
	* view or a view whose size was explicitly set.
	*/

	Dimension extentSize = null;
	Dimension viewSize = null;
	Component view = null;

	if (viewport != null) {
	extentSize = viewport.getPreferredSize();
	view = viewport.getView();
	if (view != null) {
	viewSize = view.getPreferredSize();
	} else {
	viewSize = new Dimension(0, 0);
	}
	}

	/* If there's a viewport add its preferredSize.
	*/

	if (extentSize != null) {
	prefWidth += extentSize.width;
	prefHeight += extentSize.height;
	}

	/* If there's a JScrollPane.viewportBorder, add its insets.
	*/

	Border viewportBorder = scrollPane.getViewportBorder();
	if (viewportBorder != null) {
	Insets vpbInsets = viewportBorder.getBorderInsets(parent);
	prefWidth += vpbInsets.left + vpbInsets.right;
	prefHeight += vpbInsets.top + vpbInsets.bottom;
	}

	/* If a header exists and it's visible, factor its
	* preferred size in.
	*/

	if ((rowHead != null) && rowHead.isVisible()) {
	prefWidth += rowHead.getPreferredSize().width;
	}

	if ((colHead != null) && colHead.isVisible()) {
	prefHeight += colHead.getPreferredSize().height;
	}

	/* If a scrollbar is going to appear, factor its preferred size in.
	* If the scrollbars policy is AS_NEEDED, this can be a little
	* tricky:
	*
	* - If the view is a Scrollable then scrollableTracksViewportWidth
	* and scrollableTracksViewportHeight can be used to effectively
	* disable scrolling (if they're true) in their respective dimensions.
	*
	* - Assuming that a scrollbar hasn't been disabled by the
	* previous constraint, we need to decide if the scrollbar is going
	* to appear to correctly compute the JScrollPanes preferred size.
	* To do this we compare the preferredSize of the viewport (the
	* extentSize) to the preferredSize of the view. Although we're
	* not responsible for laying out the view we'll assume that the
	* JViewport will always give it its preferredSize.
	*/

	if ((vsb != null) && (vsbPolicy != VERTICAL_SCROLLBAR_NEVER)) {
	if (vsbPolicy == VERTICAL_SCROLLBAR_ALWAYS) {
	prefWidth += vsb.getPreferredSize().width;
	}
	else if ((viewSize != null) && (extentSize != null)) {
	boolean canScroll = true;
	if (view instanceof Scrollable) {
	canScroll = !((Scrollable)view).getScrollableTracksViewportHeight();
	}
	if (canScroll && (viewSize.height > extentSize.height)) {
	prefWidth += vsb.getPreferredSize().width;
	}
	}
	}

	if ((hsb != null) && (hsbPolicy != HORIZONTAL_SCROLLBAR_NEVER)) {
	if (hsbPolicy == HORIZONTAL_SCROLLBAR_ALWAYS) {
	prefHeight += hsb.getPreferredSize().height;
	}
	else if ((viewSize != null) && (extentSize != null)) {
	boolean canScroll = true;
	if (view instanceof Scrollable) {
	canScroll = !((Scrollable)view).getScrollableTracksViewportWidth();
	}
	if (canScroll && (viewSize.width > extentSize.width)) {
	prefHeight += hsb.getPreferredSize().height;
	}
	}
	}

	return new Dimension(prefWidth, prefHeight);
	}


	/**
	* The minimum size of a <code>ScrollPane</code> is the size of the insets
	* plus minimum size of the viewport, plus the scrollpane's
	* viewportBorder insets, plus the minimum size
	* of the visible headers, plus the minimum size of the
	* scrollbars whose displayPolicy isn't NEVER.
	*
	* @param parent the <code>Container</code> that will be laid out
	* @return a <code>Dimension</code> object specifying the minimum size
	*/
	public Dimension minimumLayoutSize(Container parent)
	{
	/* Sync the (now obsolete) policy fields with the
	* JScrollPane.
	*/
	JScrollPane scrollPane = (JScrollPane)parent;
	vsbPolicy = scrollPane.getVerticalScrollBarPolicy();
	hsbPolicy = scrollPane.getHorizontalScrollBarPolicy();

	Insets insets = parent.getInsets();
	int minWidth = insets.left + insets.right;
	int minHeight = insets.top + insets.bottom;

	/* If there's a viewport add its minimumSize.
	*/

	if (viewport != null) {
	Dimension size = viewport.getMinimumSize();
	minWidth += size.width;
	minHeight += size.height;
	}

	/* If there's a JScrollPane.viewportBorder, add its insets.
	*/

	Border viewportBorder = scrollPane.getViewportBorder();
	if (viewportBorder != null) {
	Insets vpbInsets = viewportBorder.getBorderInsets(parent);
	minWidth += vpbInsets.left + vpbInsets.right;
	minHeight += vpbInsets.top + vpbInsets.bottom;
	}

	/* If a header exists and it's visible, factor its
	* minimum size in.
	*/

	if ((rowHead != null) && rowHead.isVisible()) {
	Dimension size = rowHead.getMinimumSize();
	minWidth += size.width;
	minHeight = Math.max(minHeight, size.height);
	}

	if ((colHead != null) && colHead.isVisible()) {
	Dimension size = colHead.getMinimumSize();
	minWidth = Math.max(minWidth, size.width);
	minHeight += size.height;
	}

	/* If a scrollbar might appear, factor its minimum
	* size in.
	*/

	if ((vsb != null) && (vsbPolicy != VERTICAL_SCROLLBAR_NEVER)) {
	Dimension size = vsb.getMinimumSize();
	minWidth += size.width;
	minHeight = Math.max(minHeight, size.height);
	}

	if ((hsb != null) && (hsbPolicy != HORIZONTAL_SCROLLBAR_NEVER)) {
	Dimension size = hsb.getMinimumSize();
	minWidth = Math.max(minWidth, size.width);
	minHeight += size.height;
	}

	return new Dimension(minWidth, minHeight);
	}


	/**
	* Lays out the scrollpane. The positioning of components depends on
	* the following constraints:
	* <ul>
	* <li> The row header, if present and visible, gets its preferred
	* width and the viewport's height.
	*
	* <li> The column header, if present and visible, gets its preferred
	* height and the viewport's width.
	*
	* <li> If a vertical scrollbar is needed, i.e. if the viewport's extent
	* height is smaller than its view height or if the <code>displayPolicy</code>
	* is ALWAYS, it's treated like the row header with respect to its
	* dimensions and is made visible.
	*
	* <li> If a horizontal scrollbar is needed, it is treated like the
	* column header (see the paragraph above regarding the vertical scrollbar).
	*
	* <li> If the scrollpane has a non-<code>null</code>
	* <code>viewportBorder</code>, then space is allocated for that.
	*
	* <li> The viewport gets the space available after accounting for
	* the previous constraints.
	*
	* <li> The corner components, if provided, are aligned with the
	* ends of the scrollbars and headers. If there is a vertical
	* scrollbar, the right corners appear; if there is a horizontal
	* scrollbar, the lower corners appear; a row header gets left
	* corners, and a column header gets upper corners.
	* </ul>
	*
	* @param parent the <code>Container</code> to lay out
	*/
	public void layoutContainer(Container parent)
	{
	/* Sync the (now obsolete) policy fields with the
	* JScrollPane.
	*/
	JScrollPane scrollPane = (JScrollPane)parent;
	vsbPolicy = scrollPane.getVerticalScrollBarPolicy();
	hsbPolicy = scrollPane.getHorizontalScrollBarPolicy();

	Rectangle availR = scrollPane.getBounds();
	availR.x = availR.y = 0;

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

	/* Get the scrollPane's orientation.
	*/
	boolean leftToRight = SwingUtilities.isLeftToRight(scrollPane);

	/* If there's a visible column header remove the space it
	* needs from the top of availR. The column header is treated
	* as if it were fixed height, arbitrary width.
	*/

	Rectangle colHeadR = new Rectangle(0, availR.y, 0, 0);

	if ((colHead != null) && (colHead.isVisible())) {
	int colHeadHeight = Math.min(availR.height,
	colHead.getPreferredSize().height);
	colHeadR.height = colHeadHeight;
	availR.y += colHeadHeight;
	availR.height -= colHeadHeight;
	}

	/* If there's a visible row header remove the space it needs
	* from the left or right of availR. The row header is treated
	* as if it were fixed width, arbitrary height.
	*/

	Rectangle rowHeadR = new Rectangle(0, 0, 0, 0);

	if ((rowHead != null) && (rowHead.isVisible())) {
	int rowHeadWidth = Math.min(availR.width,
	rowHead.getPreferredSize().width);
	rowHeadR.width = rowHeadWidth;
	availR.width -= rowHeadWidth;
	if ( leftToRight ) {
	rowHeadR.x = availR.x;
	availR.x += rowHeadWidth;
	} else {
	rowHeadR.x = availR.x + availR.width;
	}
	}

	/* If there's a JScrollPane.viewportBorder, remove the
	* space it occupies for availR.
	*/

	Border viewportBorder = scrollPane.getViewportBorder();
	Insets vpbInsets;
	if (viewportBorder != null) {
	vpbInsets = viewportBorder.getBorderInsets(parent);
	availR.x += vpbInsets.left;
	availR.y += vpbInsets.top;
	availR.width -= vpbInsets.left + vpbInsets.right;
	availR.height -= vpbInsets.top + vpbInsets.bottom;
	}
	else {
	vpbInsets = new Insets(0,0,0,0);
	}


	/* At this point availR is the space available for the viewport
	* and scrollbars. rowHeadR is correct except for its height and y
	* and colHeadR is correct except for its width and x. Once we're
	* through computing the dimensions of these three parts we can
	* go back and set the dimensions of rowHeadR.height, rowHeadR.y,
	* colHeadR.width, colHeadR.x and the bounds for the corners.
	*
	* We'll decide about putting up scrollbars by comparing the
	* viewport views preferred size with the viewports extent
	* size (generally just its size). Using the preferredSize is
	* reasonable because layout proceeds top down - so we expect
	* the viewport to be laid out next. And we assume that the
	* viewports layout manager will give the view it's preferred
	* size. One exception to this is when the view implements
	* Scrollable and Scrollable.getViewTracksViewport{Width,Height}
	* methods return true. If the view is tracking the viewports
	* width we don't bother with a horizontal scrollbar, similarly
	* if view.getViewTracksViewport(Height) is true we don't bother
	* with a vertical scrollbar.
	*/

	Component view = (viewport != null) ? viewport.getView() : null;
	Dimension viewPrefSize =
	(view != null) ? view.getPreferredSize()
	: new Dimension(0,0);

	Dimension extentSize =
	(viewport != null) ? viewport.toViewCoordinates(availR.getSize())
	: new Dimension(0,0);

	boolean viewTracksViewportWidth = false;
	boolean viewTracksViewportHeight = false;
	boolean isEmpty = (availR.width < 0 \|\| availR.height < 0);
	Scrollable sv;
	// Don't bother checking the Scrollable methods if there is no room
	// for the viewport, we aren't going to show any scrollbars in this
	// case anyway.
	if (!isEmpty && view instanceof Scrollable) {
	sv = (Scrollable)view;
	viewTracksViewportWidth = sv.getScrollableTracksViewportWidth();
	viewTracksViewportHeight = sv.getScrollableTracksViewportHeight();
	}
	else {
	sv = null;
	}

	/* If there's a vertical scrollbar and we need one, allocate
	* space for it (we'll make it visible later). A vertical
	* scrollbar is considered to be fixed width, arbitrary height.
	*/

	Rectangle vsbR = new Rectangle(0, availR.y - vpbInsets.top, 0, 0);

	boolean vsbNeeded;
	if (isEmpty) {
	vsbNeeded = false;
	}
	else if (vsbPolicy == VERTICAL_SCROLLBAR_ALWAYS) {
	vsbNeeded = true;
	}
	else if (vsbPolicy == VERTICAL_SCROLLBAR_NEVER) {
	vsbNeeded = false;
	}
	else { // vsbPolicy == VERTICAL_SCROLLBAR_AS_NEEDED
	vsbNeeded = !viewTracksViewportHeight && (viewPrefSize.height > extentSize.height);
	}


	if ((vsb != null) && vsbNeeded) {
	adjustForVSB(true, availR, vsbR, vpbInsets, leftToRight);
	extentSize = viewport.toViewCoordinates(availR.getSize());
	}

	/* If there's a horizontal scrollbar and we need one, allocate
	* space for it (we'll make it visible later). A horizontal
	* scrollbar is considered to be fixed height, arbitrary width.
	*/

	Rectangle hsbR = new Rectangle(availR.x - vpbInsets.left, 0, 0, 0);
	boolean hsbNeeded;
	if (isEmpty) {
	hsbNeeded = false;
	}
	else if (hsbPolicy == HORIZONTAL_SCROLLBAR_ALWAYS) {
	hsbNeeded = true;
	}
	else if (hsbPolicy == HORIZONTAL_SCROLLBAR_NEVER) {
	hsbNeeded = false;
	}
	else { // hsbPolicy == HORIZONTAL_SCROLLBAR_AS_NEEDED
	hsbNeeded = !viewTracksViewportWidth && (viewPrefSize.width > extentSize.width);
	}

	if ((hsb != null) && hsbNeeded) {
	adjustForHSB(true, availR, hsbR, vpbInsets);

	/* If we added the horizontal scrollbar then we've implicitly
	* reduced the vertical space available to the viewport.
	* As a consequence we may have to add the vertical scrollbar,
	* if that hasn't been done so already. Of course we
	* don't bother with any of this if the vsbPolicy is NEVER.
	*/
	if ((vsb != null) && !vsbNeeded &&
	(vsbPolicy != VERTICAL_SCROLLBAR_NEVER)) {

	extentSize = viewport.toViewCoordinates(availR.getSize());
	vsbNeeded = viewPrefSize.height > extentSize.height;

	if (vsbNeeded) {
	adjustForVSB(true, availR, vsbR, vpbInsets, leftToRight);
	}
	}
	}

	/* Set the size of the viewport first, and then recheck the Scrollable
	* methods. Some components base their return values for the Scrollable
	* methods on the size of the Viewport, so that if we don't
	* ask after resetting the bounds we may have gotten the wrong
	* answer.
	*/

	if (viewport != null) {
	viewport.setBounds(availR);

	if (sv != null) {
	extentSize = viewport.toViewCoordinates(availR.getSize());

	boolean oldHSBNeeded = hsbNeeded;
	boolean oldVSBNeeded = vsbNeeded;
	viewTracksViewportWidth = sv.
	getScrollableTracksViewportWidth();
	viewTracksViewportHeight = sv.
	getScrollableTracksViewportHeight();
	if (vsb != null && vsbPolicy == VERTICAL_SCROLLBAR_AS_NEEDED) {
	boolean newVSBNeeded = !viewTracksViewportHeight &&
	(viewPrefSize.height > extentSize.height);
	if (newVSBNeeded != vsbNeeded) {
	vsbNeeded = newVSBNeeded;
	adjustForVSB(vsbNeeded, availR, vsbR, vpbInsets,
	leftToRight);
	extentSize = viewport.toViewCoordinates
	(availR.getSize());
	}
	}
	if (hsb != null && hsbPolicy ==HORIZONTAL_SCROLLBAR_AS_NEEDED){
	boolean newHSBbNeeded = !viewTracksViewportWidth &&
	(viewPrefSize.width > extentSize.width);
	if (newHSBbNeeded != hsbNeeded) {
	hsbNeeded = newHSBbNeeded;
	adjustForHSB(hsbNeeded, availR, hsbR, vpbInsets);
	if ((vsb != null) && !vsbNeeded &&
	(vsbPolicy != VERTICAL_SCROLLBAR_NEVER)) {

	extentSize = viewport.toViewCoordinates
	(availR.getSize());
	vsbNeeded = viewPrefSize.height >
	extentSize.height;

	if (vsbNeeded) {
	adjustForVSB(true, availR, vsbR, vpbInsets,
	leftToRight);
	}
	}
	}
	}
	if (oldHSBNeeded != hsbNeeded \|\|
	oldVSBNeeded != vsbNeeded) {
	viewport.setBounds(availR);
	// You could argue that we should recheck the
	// Scrollable methods again until they stop changing,
	// but they might never stop changing, so we stop here
	// and don't do any additional checks.
	}
	}
	}

	/* We now have the final size of the viewport: availR.
	* Now fixup the header and scrollbar widths/heights.
	*/
	vsbR.height = availR.height + vpbInsets.top + vpbInsets.bottom;
	hsbR.width = availR.width + vpbInsets.left + vpbInsets.right;
	rowHeadR.height = availR.height + vpbInsets.top + vpbInsets.bottom;
	rowHeadR.y = availR.y - vpbInsets.top;
	colHeadR.width = availR.width + vpbInsets.left + vpbInsets.right;
	colHeadR.x = availR.x - vpbInsets.left;

	/* Set the bounds of the remaining components. The scrollbars
	* are made invisible if they're not needed.
	*/

	if (rowHead != null) {
	rowHead.setBounds(rowHeadR);
	}

	if (colHead != null) {
	colHead.setBounds(colHeadR);
	}

	if (vsb != null) {
	if (vsbNeeded) {
	if (colHead != null &&
	UIManager.getBoolean("ScrollPane.fillUpperCorner"))
	{
	if ((leftToRight && upperRight == null) \|\|
	(!leftToRight && upperLeft == null))
	{
	// This is used primarily for GTK L&F, which needs to
	// extend the vertical scrollbar to fill the upper
	// corner near the column header. Note that we skip
	// this step (and use the default behavior) if the
	// user has set a custom corner component.
	vsbR.y = colHeadR.y;
	vsbR.height += colHeadR.height;
	}
	}
	vsb.setVisible(true);
	vsb.setBounds(vsbR);
	}
	else {
	vsb.setVisible(false);
	}
	}

	if (hsb != null) {
	if (hsbNeeded) {
	if (rowHead != null &&
	UIManager.getBoolean("ScrollPane.fillLowerCorner"))
	{
	if ((leftToRight && lowerLeft == null) \|\|
	(!leftToRight && lowerRight == null))
	{
	// This is used primarily for GTK L&F, which needs to
	// extend the horizontal scrollbar to fill the lower
	// corner near the row header. Note that we skip
	// this step (and use the default behavior) if the
	// user has set a custom corner component.
	if (leftToRight) {
	hsbR.x = rowHeadR.x;
	}
	hsbR.width += rowHeadR.width;
	}
	}
	hsb.setVisible(true);
	hsb.setBounds(hsbR);
	}
	else {
	hsb.setVisible(false);
	}
	}

	if (lowerLeft != null) {
	lowerLeft.setBounds(leftToRight ? rowHeadR.x : vsbR.x,
	hsbR.y,
	leftToRight ? rowHeadR.width : vsbR.width,
	hsbR.height);
	}

	if (lowerRight != null) {
	lowerRight.setBounds(leftToRight ? vsbR.x : rowHeadR.x,
	hsbR.y,
	leftToRight ? vsbR.width : rowHeadR.width,
	hsbR.height);
	}

	if (upperLeft != null) {
	upperLeft.setBounds(leftToRight ? rowHeadR.x : vsbR.x,
	colHeadR.y,
	leftToRight ? rowHeadR.width : vsbR.width,
	colHeadR.height);
	}

	if (upperRight != null) {
	upperRight.setBounds(leftToRight ? vsbR.x : rowHeadR.x,
	colHeadR.y,
	leftToRight ? vsbR.width : rowHeadR.width,
	colHeadR.height);
	}
	}

	/**
	* Adjusts the <code>Rectangle</code> <code>available</code> based on if
	* the vertical scrollbar is needed (<code>wantsVSB</code>).
	* The location of the vsb is updated in <code>vsbR</code>, and
	* the viewport border insets (<code>vpbInsets</code>) are used to offset
	* the vsb. This is only called when <code>wantsVSB</code> has
	* changed, eg you shouldn't invoke adjustForVSB(true) twice.
	*/
	private void adjustForVSB(boolean wantsVSB, Rectangle available,
	Rectangle vsbR, Insets vpbInsets,
	boolean leftToRight) {
	int oldWidth = vsbR.width;
	if (wantsVSB) {
	int vsbWidth = Math.max(0, Math.min(vsb.getPreferredSize().width,
	available.width));

	available.width -= vsbWidth;
	vsbR.width = vsbWidth;

	if( leftToRight ) {
	vsbR.x = available.x + available.width + vpbInsets.right;
	} else {
	vsbR.x = available.x - vpbInsets.left;
	available.x += vsbWidth;
	}
	}
	else {
	available.width += oldWidth;
	}
	}

	/**
	* Adjusts the <code>Rectangle</code> <code>available</code> based on if
	* the horizontal scrollbar is needed (<code>wantsHSB</code>).
	* The location of the hsb is updated in <code>hsbR</code>, and
	* the viewport border insets (<code>vpbInsets</code>) are used to offset
	* the hsb. This is only called when <code>wantsHSB</code> has
	* changed, eg you shouldn't invoked adjustForHSB(true) twice.
	*/
	private void adjustForHSB(boolean wantsHSB, Rectangle available,
	Rectangle hsbR, Insets vpbInsets) {
	int oldHeight = hsbR.height;
	if (wantsHSB) {
	int hsbHeight = Math.max(0, Math.min(available.height,
	hsb.getPreferredSize().height));

	available.height -= hsbHeight;
	hsbR.y = available.y + available.height + vpbInsets.bottom;
	hsbR.height = hsbHeight;
	}
	else {
	available.height += oldHeight;
	}
	}



	/**
	* Returns the bounds of the border around the specified scroll pane's
	* viewport.
	*
	* @return the size and position of the viewport border
	* @deprecated As of JDK version Swing1.1
	* replaced by <code>JScrollPane.getViewportBorderBounds()</code>.
	*/
	@Deprecated
	public Rectangle getViewportBorderBounds(JScrollPane scrollpane) {
	return scrollpane.getViewportBorderBounds();
	}

	/**
	* The UI resource version of <code>ScrollPaneLayout</code>.
	*/
	public static class UIResource extends ScrollPaneLayout implements javax.swing.plaf.UIResource {}
	}

Back to index...