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 java.beans.ConstructorProperties;
	import javax.swing.plaf.*;
	import javax.accessibility.*;

	import java.awt.*;

	import java.io.ObjectOutputStream;
	import java.io.ObjectInputStream;
	import java.io.IOException;



	/**
	* <code>JSplitPane</code> is used to divide two (and only two)
	* <code>Component</code>s. The two <code>Component</code>s
	* are graphically divided based on the look and feel
	* implementation, and the two <code>Component</code>s can then be
	* interactively resized by the user.
	* Information on using <code>JSplitPane</code> is in
	* <a
	href="https://docs.oracle.com/javase/tutorial/uiswing/components/splitpane.html">How to Use Split Panes</a> in
	* <em>The Java Tutorial</em>.
	* <p>
	* The two <code>Component</code>s in a split pane can be aligned
	* left to right using
	* <code>JSplitPane.HORIZONTAL_SPLIT</code>, or top to bottom using
	* <code>JSplitPane.VERTICAL_SPLIT</code>.
	* The preferred way to change the size of the <code>Component</code>s
	* is to invoke
	* <code>setDividerLocation</code> where <code>location</code> is either
	* the new x or y position, depending on the orientation of the
	* <code>JSplitPane</code>.
	* <p>
	* To resize the <code>Component</code>s to their preferred sizes invoke
	* <code>resetToPreferredSizes</code>.
	* <p>
	* When the user is resizing the <code>Component</code>s the minimum
	* size of the <code>Components</code> is used to determine the
	* maximum/minimum position the <code>Component</code>s
	* can be set to. If the minimum size of the two
	* components is greater than the size of the split pane the divider
	* will not allow you to resize it. To alter the minimum size of a
	* <code>JComponent</code>, see {@link JComponent#setMinimumSize}.
	* <p>
	* When the user resizes the split pane the new space is distributed between
	* the two components based on the <code>resizeWeight</code> property.
	* A value of 0,
	* the default, indicates the right/bottom component gets all the space,
	* where as a value of 1 indicates the left/top component gets all the space.
	* <p>
	* <strong>Warning:</strong> Swing is not thread safe. For more
	* information see <a
	* href="package-summary.html#threading">Swing's Threading
	* Policy</a>.
	* <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 #setDividerLocation
	* @see #resetToPreferredSizes
	*
	* @author Scott Violet
	*/
	public class JSplitPane extends JComponent implements Accessible
	{
	/**
	* @see #getUIClassID
	* @see #readObject
	*/
	private static final String uiClassID = "SplitPaneUI";

	/**
	* Vertical split indicates the <code>Component</code>s are
	* split along the y axis. For example the two
	* <code>Component</code>s will be split one on top of the other.
	*/
	public final static int VERTICAL_SPLIT = 0;

	/**
	* Horizontal split indicates the <code>Component</code>s are
	* split along the x axis. For example the two
	* <code>Component</code>s will be split one to the left of the
	* other.
	*/
	public final static int HORIZONTAL_SPLIT = 1;

	/**
	* Used to add a <code>Component</code> to the left of the other
	* <code>Component</code>.
	*/
	public final static String LEFT = "left";

	/**
	* Used to add a <code>Component</code> to the right of the other
	* <code>Component</code>.
	*/
	public final static String RIGHT = "right";

	/**
	* Used to add a <code>Component</code> above the other
	* <code>Component</code>.
	*/
	public final static String TOP = "top";

	/**
	* Used to add a <code>Component</code> below the other
	* <code>Component</code>.
	*/
	public final static String BOTTOM = "bottom";

	/**
	* Used to add a <code>Component</code> that will represent the divider.
	*/
	public final static String DIVIDER = "divider";

	/**
	* Bound property name for orientation (horizontal or vertical).
	*/
	public final static String ORIENTATION_PROPERTY = "orientation";

	/**
	* Bound property name for continuousLayout.
	*/
	public final static String CONTINUOUS_LAYOUT_PROPERTY = "continuousLayout";

	/**
	* Bound property name for border.
	*/
	public final static String DIVIDER_SIZE_PROPERTY = "dividerSize";

	/**
	* Bound property for oneTouchExpandable.
	*/
	public final static String ONE_TOUCH_EXPANDABLE_PROPERTY =
	"oneTouchExpandable";

	/**
	* Bound property for lastLocation.
	*/
	public final static String LAST_DIVIDER_LOCATION_PROPERTY =
	"lastDividerLocation";

	/**
	* Bound property for the dividerLocation.
	* @since 1.3
	*/
	public final static String DIVIDER_LOCATION_PROPERTY = "dividerLocation";

	/**
	* Bound property for weight.
	* @since 1.3
	*/
	public final static String RESIZE_WEIGHT_PROPERTY = "resizeWeight";

	/**
	* How the views are split.
	*/
	protected int orientation;

	/**
	* Whether or not the views are continuously redisplayed while
	* resizing.
	*/
	protected boolean continuousLayout;

	/**
	* The left or top component.
	*/
	protected Component leftComponent;

	/**
	* The right or bottom component.
	*/
	protected Component rightComponent;

	/**
	* Size of the divider.
	*/
	protected int dividerSize;
	private boolean dividerSizeSet = false;

	/**
	* Is a little widget provided to quickly expand/collapse the
	* split pane?
	*/
	protected boolean oneTouchExpandable;
	private boolean oneTouchExpandableSet;

	/**
	* Previous location of the split pane.
	*/
	protected int lastDividerLocation;

	/**
	* How to distribute extra space.
	*/
	private double resizeWeight;

	/**
	* Location of the divider, at least the value that was set, the UI may
	* have a different value.
	*/
	private int dividerLocation;


	/**
	* Creates a new <code>JSplitPane</code> configured to arrange the child
	* components side-by-side horizontally, using two buttons for the components.
	*/
	public JSplitPane() {
	this(JSplitPane.HORIZONTAL_SPLIT,
	UIManager.getBoolean("SplitPane.continuousLayout"),
	new JButton(UIManager.getString("SplitPane.leftButtonText")),
	new JButton(UIManager.getString("SplitPane.rightButtonText")));
	}


	/**
	* Creates a new <code>JSplitPane</code> configured with the
	* specified orientation.
	*
	* @param newOrientation <code>JSplitPane.HORIZONTAL_SPLIT</code> or
	* <code>JSplitPane.VERTICAL_SPLIT</code>
	* @exception IllegalArgumentException if <code>orientation</code>
	* is not one of HORIZONTAL_SPLIT or VERTICAL_SPLIT.
	*/
	@ConstructorProperties({"orientation"})
	public JSplitPane(int newOrientation) {
	this(newOrientation,
	UIManager.getBoolean("SplitPane.continuousLayout"));
	}


	/**
	* Creates a new <code>JSplitPane</code> with the specified
	* orientation and redrawing style.
	*
	* @param newOrientation <code>JSplitPane.HORIZONTAL_SPLIT</code> or
	* <code>JSplitPane.VERTICAL_SPLIT</code>
	* @param newContinuousLayout a boolean, true for the components to
	* redraw continuously as the divider changes position, false
	* to wait until the divider position stops changing to redraw
	* @exception IllegalArgumentException if <code>orientation</code>
	* is not one of HORIZONTAL_SPLIT or VERTICAL_SPLIT
	*/
	public JSplitPane(int newOrientation,
	boolean newContinuousLayout) {
	this(newOrientation, newContinuousLayout, null, null);
	}


	/**
	* Creates a new <code>JSplitPane</code> with the specified
	* orientation and the specified components.
	*
	* @param newOrientation <code>JSplitPane.HORIZONTAL_SPLIT</code> or
	* <code>JSplitPane.VERTICAL_SPLIT</code>
	* @param newLeftComponent the <code>Component</code> that will
	* appear on the left
	* of a horizontally-split pane, or at the top of a
	* vertically-split pane
	* @param newRightComponent the <code>Component</code> that will
	* appear on the right
	* of a horizontally-split pane, or at the bottom of a
	* vertically-split pane
	* @exception IllegalArgumentException if <code>orientation</code>
	* is not one of: HORIZONTAL_SPLIT or VERTICAL_SPLIT
	*/
	public JSplitPane(int newOrientation,
	Component newLeftComponent,
	Component newRightComponent){
	this(newOrientation,
	UIManager.getBoolean("SplitPane.continuousLayout"),
	newLeftComponent, newRightComponent);
	}


	/**
	* Creates a new <code>JSplitPane</code> with the specified
	* orientation and
	* redrawing style, and with the specified components.
	*
	* @param newOrientation <code>JSplitPane.HORIZONTAL_SPLIT</code> or
	* <code>JSplitPane.VERTICAL_SPLIT</code>
	* @param newContinuousLayout a boolean, true for the components to
	* redraw continuously as the divider changes position, false
	* to wait until the divider position stops changing to redraw
	* @param newLeftComponent the <code>Component</code> that will
	* appear on the left
	* of a horizontally-split pane, or at the top of a
	* vertically-split pane
	* @param newRightComponent the <code>Component</code> that will
	* appear on the right
	* of a horizontally-split pane, or at the bottom of a
	* vertically-split pane
	* @exception IllegalArgumentException if <code>orientation</code>
	* is not one of HORIZONTAL_SPLIT or VERTICAL_SPLIT
	*/
	public JSplitPane(int newOrientation,
	boolean newContinuousLayout,
	Component newLeftComponent,
	Component newRightComponent){
	super();

	dividerLocation = -1;
	setLayout(null);
	setUIProperty("opaque", Boolean.TRUE);
	orientation = newOrientation;
	if (orientation != HORIZONTAL_SPLIT && orientation != VERTICAL_SPLIT)
	throw new IllegalArgumentException("cannot create JSplitPane, " +
	"orientation must be one of " +
	"JSplitPane.HORIZONTAL_SPLIT " +
	"or JSplitPane.VERTICAL_SPLIT");
	continuousLayout = newContinuousLayout;
	if (newLeftComponent != null)
	setLeftComponent(newLeftComponent);
	if (newRightComponent != null)
	setRightComponent(newRightComponent);
	updateUI();

	}


	/**
	* Sets the L&F object that renders this component.
	*
	* @param ui the <code>SplitPaneUI</code> L&F object
	* @see UIDefaults#getUI
	* @beaninfo
	* bound: true
	* hidden: true
	* attribute: visualUpdate true
	* description: The UI object that implements the Component's LookAndFeel.
	*/
	public void setUI(SplitPaneUI ui) {
	if ((SplitPaneUI)this.ui != ui) {
	super.setUI(ui);
	revalidate();
	}
	}


	/**
	* Returns the <code>SplitPaneUI</code> that is providing the
	* current look and feel.
	*
	* @return the <code>SplitPaneUI</code> object that renders this component
	* @beaninfo
	* expert: true
	* description: The L&F object that renders this component.
	*/
	public SplitPaneUI getUI() {
	return (SplitPaneUI)ui;
	}


	/**
	* Notification from the <code>UIManager</code> that the L&F has changed.
	* Replaces the current UI object with the latest version from the
	* <code>UIManager</code>.
	*
	* @see JComponent#updateUI
	*/
	public void updateUI() {
	setUI((SplitPaneUI)UIManager.getUI(this));
	revalidate();
	}


	/**
	* Returns the name of the L&F class that renders this component.
	*
	* @return the string "SplitPaneUI"
	* @see JComponent#getUIClassID
	* @see UIDefaults#getUI
	* @beaninfo
	* expert: true
	* description: A string that specifies the name of the L&F class.
	*/
	public String getUIClassID() {
	return uiClassID;
	}


	/**
	* Sets the size of the divider.
	*
	* @param newSize an integer giving the size of the divider in pixels
	* @beaninfo
	* bound: true
	* description: The size of the divider.
	*/
	public void setDividerSize(int newSize) {
	int oldSize = dividerSize;

	dividerSizeSet = true;
	if (oldSize != newSize) {
	dividerSize = newSize;
	firePropertyChange(DIVIDER_SIZE_PROPERTY, oldSize, newSize);
	}
	}


	/**
	* Returns the size of the divider.
	*
	* @return an integer giving the size of the divider in pixels
	*/
	public int getDividerSize() {
	return dividerSize;
	}


	/**
	* Sets the component to the left (or above) the divider.
	*
	* @param comp the <code>Component</code> to display in that position
	*/
	public void setLeftComponent(Component comp) {
	if (comp == null) {
	if (leftComponent != null) {
	remove(leftComponent);
	leftComponent = null;
	}
	} else {
	add(comp, JSplitPane.LEFT);
	}
	}


	/**
	* Returns the component to the left (or above) the divider.
	*
	* @return the <code>Component</code> displayed in that position
	* @beaninfo
	* preferred: true
	* description: The component to the left (or above) the divider.
	*/
	public Component getLeftComponent() {
	return leftComponent;
	}


	/**
	* Sets the component above, or to the left of the divider.
	*
	* @param comp the <code>Component</code> to display in that position
	* @beaninfo
	* description: The component above, or to the left of the divider.
	*/
	public void setTopComponent(Component comp) {
	setLeftComponent(comp);
	}


	/**
	* Returns the component above, or to the left of the divider.
	*
	* @return the <code>Component</code> displayed in that position
	*/
	public Component getTopComponent() {
	return leftComponent;
	}


	/**
	* Sets the component to the right (or below) the divider.
	*
	* @param comp the <code>Component</code> to display in that position
	* @beaninfo
	* preferred: true
	* description: The component to the right (or below) the divider.
	*/
	public void setRightComponent(Component comp) {
	if (comp == null) {
	if (rightComponent != null) {
	remove(rightComponent);
	rightComponent = null;
	}
	} else {
	add(comp, JSplitPane.RIGHT);
	}
	}


	/**
	* Returns the component to the right (or below) the divider.
	*
	* @return the <code>Component</code> displayed in that position
	*/
	public Component getRightComponent() {
	return rightComponent;
	}


	/**
	* Sets the component below, or to the right of the divider.
	*
	* @param comp the <code>Component</code> to display in that position
	* @beaninfo
	* description: The component below, or to the right of the divider.
	*/
	public void setBottomComponent(Component comp) {
	setRightComponent(comp);
	}


	/**
	* Returns the component below, or to the right of the divider.
	*
	* @return the <code>Component</code> displayed in that position
	*/
	public Component getBottomComponent() {
	return rightComponent;
	}


	/**
	* Sets the value of the <code>oneTouchExpandable</code> property,
	* which must be <code>true</code> for the
	* <code>JSplitPane</code> to provide a UI widget
	* on the divider to quickly expand/collapse the divider.
	* The default value of this property is <code>false</code>.
	* Some look and feels might not support one-touch expanding;
	* they will ignore this property.
	*
	* @param newValue <code>true</code> to specify that the split pane should provide a
	* collapse/expand widget
	* @beaninfo
	* bound: true
	* description: UI widget on the divider to quickly
	* expand/collapse the divider.
	*
	* @see #isOneTouchExpandable
	*/
	public void setOneTouchExpandable(boolean newValue) {
	boolean oldValue = oneTouchExpandable;

	oneTouchExpandable = newValue;
	oneTouchExpandableSet = true;
	firePropertyChange(ONE_TOUCH_EXPANDABLE_PROPERTY, oldValue, newValue);
	repaint();
	}


	/**
	* Gets the <code>oneTouchExpandable</code> property.
	*
	* @return the value of the <code>oneTouchExpandable</code> property
	* @see #setOneTouchExpandable
	*/
	public boolean isOneTouchExpandable() {
	return oneTouchExpandable;
	}


	/**
	* Sets the last location the divider was at to
	* <code>newLastLocation</code>.
	*
	* @param newLastLocation an integer specifying the last divider location
	* in pixels, from the left (or upper) edge of the pane to the
	* left (or upper) edge of the divider
	* @beaninfo
	* bound: true
	* description: The last location the divider was at.
	*/
	public void setLastDividerLocation(int newLastLocation) {
	int oldLocation = lastDividerLocation;

	lastDividerLocation = newLastLocation;
	firePropertyChange(LAST_DIVIDER_LOCATION_PROPERTY, oldLocation,
	newLastLocation);
	}


	/**
	* Returns the last location the divider was at.
	*
	* @return an integer specifying the last divider location as a count
	* of pixels from the left (or upper) edge of the pane to the
	* left (or upper) edge of the divider
	*/
	public int getLastDividerLocation() {
	return lastDividerLocation;
	}


	/**
	* Sets the orientation, or how the splitter is divided. The options
	* are:<ul>
	* <li>JSplitPane.VERTICAL_SPLIT (above/below orientation of components)
	* <li>JSplitPane.HORIZONTAL_SPLIT (left/right orientation of components)
	* </ul>
	*
	* @param orientation an integer specifying the orientation
	* @exception IllegalArgumentException if orientation is not one of:
	* HORIZONTAL_SPLIT or VERTICAL_SPLIT.
	* @beaninfo
	* bound: true
	* description: The orientation, or how the splitter is divided.
	* enum: HORIZONTAL_SPLIT JSplitPane.HORIZONTAL_SPLIT
	* VERTICAL_SPLIT JSplitPane.VERTICAL_SPLIT
	*/
	public void setOrientation(int orientation) {
	if ((orientation != VERTICAL_SPLIT) &&
	(orientation != HORIZONTAL_SPLIT)) {
	throw new IllegalArgumentException("JSplitPane: orientation must " +
	"be one of " +
	"JSplitPane.VERTICAL_SPLIT or " +
	"JSplitPane.HORIZONTAL_SPLIT");
	}

	int oldOrientation = this.orientation;

	this.orientation = orientation;
	firePropertyChange(ORIENTATION_PROPERTY, oldOrientation, orientation);
	}


	/**
	* Returns the orientation.
	*
	* @return an integer giving the orientation
	* @see #setOrientation
	*/
	public int getOrientation() {
	return orientation;
	}


	/**
	* Sets the value of the <code>continuousLayout</code> property,
	* which must be <code>true</code> for the child components
	* to be continuously
	* redisplayed and laid out during user intervention.
	* The default value of this property is look and feel dependent.
	* Some look and feels might not support continuous layout;
	* they will ignore this property.
	*
	* @param newContinuousLayout <code>true</code> if the components
	* should continuously be redrawn as the divider changes position
	* @beaninfo
	* bound: true
	* description: Whether the child components are
	* continuously redisplayed and laid out during
	* user intervention.
	* @see #isContinuousLayout
	*/
	public void setContinuousLayout(boolean newContinuousLayout) {
	boolean oldCD = continuousLayout;

	continuousLayout = newContinuousLayout;
	firePropertyChange(CONTINUOUS_LAYOUT_PROPERTY, oldCD,
	newContinuousLayout);
	}


	/**
	* Gets the <code>continuousLayout</code> property.
	*
	* @return the value of the <code>continuousLayout</code> property
	* @see #setContinuousLayout
	*/
	public boolean isContinuousLayout() {
	return continuousLayout;
	}

	/**
	* Specifies how to distribute extra space when the size of the split pane
	* changes. A value of 0, the default,
	* indicates the right/bottom component gets all the extra space (the
	* left/top component acts fixed), where as a value of 1 specifies the
	* left/top component gets all the extra space (the right/bottom component
	* acts fixed). Specifically, the left/top component gets (weight * diff)
	* extra space and the right/bottom component gets (1 - weight) * diff
	* extra space.
	*
	* @param value as described above
	* @exception IllegalArgumentException if <code>value</code> is < 0 or > 1
	* @since 1.3
	* @beaninfo
	* bound: true
	* description: Specifies how to distribute extra space when the split pane
	* resizes.
	*/
	public void setResizeWeight(double value) {
	if (value < 0 \|\| value > 1) {
	throw new IllegalArgumentException("JSplitPane weight must be between 0 and 1");
	}
	double oldWeight = resizeWeight;

	resizeWeight = value;
	firePropertyChange(RESIZE_WEIGHT_PROPERTY, oldWeight, value);
	}

	/**
	* Returns the number that determines how extra space is distributed.
	* @return how extra space is to be distributed on a resize of the
	* split pane
	* @since 1.3
	*/
	public double getResizeWeight() {
	return resizeWeight;
	}

	/**
	* Lays out the <code>JSplitPane</code> layout based on the preferred size
	* of the children components. This will likely result in changing
	* the divider location.
	*/
	public void resetToPreferredSizes() {
	SplitPaneUI ui = getUI();

	if (ui != null) {
	ui.resetToPreferredSizes(this);
	}
	}


	/**
	* Sets the divider location as a percentage of the
	* <code>JSplitPane</code>'s size.
	* <p>
	* This method is implemented in terms of
	* <code>setDividerLocation(int)</code>.
	* This method immediately changes the size of the split pane based on
	* its current size. If the split pane is not correctly realized and on
	* screen, this method will have no effect (new divider location will
	* become (current size * proportionalLocation) which is 0).
	*
	* @param proportionalLocation a double-precision floating point value
	* that specifies a percentage, from zero (top/left) to 1.0
	* (bottom/right)
	* @exception IllegalArgumentException if the specified location is < 0
	* or > 1.0
	* @beaninfo
	* description: The location of the divider.
	*/
	public void setDividerLocation(double proportionalLocation) {
	if (proportionalLocation < 0.0 \|\|
	proportionalLocation > 1.0) {
	throw new IllegalArgumentException("proportional location must " +
	"be between 0.0 and 1.0.");
	}
	if (getOrientation() == VERTICAL_SPLIT) {
	setDividerLocation((int)((double)(getHeight() - getDividerSize()) *
	proportionalLocation));
	} else {
	setDividerLocation((int)((double)(getWidth() - getDividerSize()) *
	proportionalLocation));
	}
	}


	/**
	* Sets the location of the divider. This is passed off to the
	* look and feel implementation, and then listeners are notified. A value
	* less than 0 implies the divider should be reset to a value that
	* attempts to honor the preferred size of the left/top component.
	* After notifying the listeners, the last divider location is updated,
	* via <code>setLastDividerLocation</code>.
	*
	* @param location an int specifying a UI-specific value (typically a
	* pixel count)
	* @beaninfo
	* bound: true
	* description: The location of the divider.
	*/
	public void setDividerLocation(int location) {
	int oldValue = dividerLocation;

	dividerLocation = location;

	// Notify UI.
	SplitPaneUI ui = getUI();

	if (ui != null) {
	ui.setDividerLocation(this, location);
	}

	// Then listeners
	firePropertyChange(DIVIDER_LOCATION_PROPERTY, oldValue, location);

	// And update the last divider location.
	setLastDividerLocation(oldValue);
	}


	/**
	* Returns the last value passed to <code>setDividerLocation</code>.
	* The value returned from this method may differ from the actual
	* divider location (if <code>setDividerLocation</code> was passed a
	* value bigger than the current size).
	*
	* @return an integer specifying the location of the divider
	*/
	public int getDividerLocation() {
	return dividerLocation;
	}


	/**
	* Returns the minimum location of the divider from the look and feel
	* implementation.
	*
	* @return an integer specifying a UI-specific value for the minimum
	* location (typically a pixel count); or -1 if the UI is
	* <code>null</code>
	* @beaninfo
	* description: The minimum location of the divider from the L&F.
	*/
	public int getMinimumDividerLocation() {
	SplitPaneUI ui = getUI();

	if (ui != null) {
	return ui.getMinimumDividerLocation(this);
	}
	return -1;
	}


	/**
	* Returns the maximum location of the divider from the look and feel
	* implementation.
	*
	* @return an integer specifying a UI-specific value for the maximum
	* location (typically a pixel count); or -1 if the UI is
	* <code>null</code>
	*/
	public int getMaximumDividerLocation() {
	SplitPaneUI ui = getUI();

	if (ui != null) {
	return ui.getMaximumDividerLocation(this);
	}
	return -1;
	}


	/**
	* Removes the child component, <code>component</code> from the
	* pane. Resets the <code>leftComponent</code> or
	* <code>rightComponent</code> instance variable, as necessary.
	*
	* @param component the <code>Component</code> to remove
	*/
	public void remove(Component component) {
	if (component == leftComponent) {
	leftComponent = null;
	} else if (component == rightComponent) {
	rightComponent = null;
	}
	super.remove(component);

	// Update the JSplitPane on the screen
	revalidate();
	repaint();
	}


	/**
	* Removes the <code>Component</code> at the specified index.
	* Updates the <code>leftComponent</code> and <code>rightComponent</code>
	* instance variables as necessary, and then messages super.
	*
	* @param index an integer specifying the component to remove, where
	* 1 specifies the left/top component and 2 specifies the
	* bottom/right component
	*/
	public void remove(int index) {
	Component comp = getComponent(index);

	if (comp == leftComponent) {
	leftComponent = null;
	} else if (comp == rightComponent) {
	rightComponent = null;
	}
	super.remove(index);

	// Update the JSplitPane on the screen
	revalidate();
	repaint();
	}


	/**
	* Removes all the child components from the split pane. Resets the
	* <code>leftComonent</code> and <code>rightComponent</code>
	* instance variables.
	*/
	public void removeAll() {
	leftComponent = rightComponent = null;
	super.removeAll();

	// Update the JSplitPane on the screen
	revalidate();
	repaint();
	}


	/**
	* Returns true, so that calls to <code>revalidate</code>
	* on any descendant of this <code>JSplitPane</code>
	* will cause a request to be queued that
	* will validate the <code>JSplitPane</code> and all its descendants.
	*
	* @return true
	* @see JComponent#revalidate
	* @see java.awt.Container#isValidateRoot
	*
	* @beaninfo
	* hidden: true
	*/
	@Override
	public boolean isValidateRoot() {
	return true;
	}


	/**
	* Adds the specified component to this split pane.
	* If <code>constraints</code> identifies the left/top or
	* right/bottom child component, and a component with that identifier
	* was previously added, it will be removed and then <code>comp</code>
	* will be added in its place. If <code>constraints</code> is not
	* one of the known identifiers the layout manager may throw an
	* <code>IllegalArgumentException</code>.
	* <p>
	* The possible constraints objects (Strings) are:
	* <ul>
	* <li>JSplitPane.TOP
	* <li>JSplitPane.LEFT
	* <li>JSplitPane.BOTTOM
	* <li>JSplitPane.RIGHT
	* </ul>
	* If the <code>constraints</code> object is <code>null</code>,
	* the component is added in the
	* first available position (left/top if open, else right/bottom).
	*
	* @param comp the component to add
	* @param constraints an <code>Object</code> specifying the
	* layout constraints
	* (position) for this component
	* @param index an integer specifying the index in the container's
	* list.
	* @exception IllegalArgumentException if the <code>constraints</code>
	* object does not match an existing component
	* @see java.awt.Container#addImpl(Component, Object, int)
	*/
	protected void addImpl(Component comp, Object constraints, int index)
	{
	Component toRemove;

	if (constraints != null && !(constraints instanceof String)) {
	throw new IllegalArgumentException("cannot add to layout: " +
	"constraint must be a string " +
	"(or null)");
	}

	/* If the constraints are null and the left/right component is
	invalid, add it at the left/right component. */
	if (constraints == null) {
	if (getLeftComponent() == null) {
	constraints = JSplitPane.LEFT;
	} else if (getRightComponent() == null) {
	constraints = JSplitPane.RIGHT;
	}
	}

	/* Find the Component that already exists and remove it. */
	if (constraints != null && (constraints.equals(JSplitPane.LEFT) \|\|
	constraints.equals(JSplitPane.TOP))) {
	toRemove = getLeftComponent();
	if (toRemove != null) {
	remove(toRemove);
	}
	leftComponent = comp;
	index = -1;
	} else if (constraints != null &&
	(constraints.equals(JSplitPane.RIGHT) \|\|
	constraints.equals(JSplitPane.BOTTOM))) {
	toRemove = getRightComponent();
	if (toRemove != null) {
	remove(toRemove);
	}
	rightComponent = comp;
	index = -1;
	} else if (constraints != null &&
	constraints.equals(JSplitPane.DIVIDER)) {
	index = -1;
	}
	/* LayoutManager should raise for else condition here. */

	super.addImpl(comp, constraints, index);

	// Update the JSplitPane on the screen
	revalidate();
	repaint();
	}


	/**
	* Subclassed to message the UI with <code>finishedPaintingChildren</code>
	* after super has been messaged, as well as painting the border.
	*
	* @param g the <code>Graphics</code> context within which to paint
	*/
	protected void paintChildren(Graphics g) {
	super.paintChildren(g);

	SplitPaneUI ui = getUI();

	if (ui != null) {
	Graphics tempG = g.create();
	ui.finishedPaintingChildren(this, tempG);
	tempG.dispose();
	}
	}


	/**
	* See <code>readObject</code> and <code>writeObject</code> in
	* <code>JComponent</code> for more
	* information about serialization in Swing.
	*/
	private void writeObject(ObjectOutputStream s) throws IOException {
	s.defaultWriteObject();
	if (getUIClassID().equals(uiClassID)) {
	byte count = JComponent.getWriteObjCounter(this);
	JComponent.setWriteObjCounter(this, --count);
	if (count == 0 && ui != null) {
	ui.installUI(this);
	}
	}
	}

	void setUIProperty(String propertyName, Object value) {
	if (propertyName == "dividerSize") {
	if (!dividerSizeSet) {
	setDividerSize(((Number)value).intValue());
	dividerSizeSet = false;
	}
	} else if (propertyName == "oneTouchExpandable") {
	if (!oneTouchExpandableSet) {
	setOneTouchExpandable(((Boolean)value).booleanValue());
	oneTouchExpandableSet = false;
	}
	} else {
	super.setUIProperty(propertyName, value);
	}
	}


	/**
	* Returns a string representation of this <code>JSplitPane</code>.
	* 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 <code>null</code>.
	*
	* @return a string representation of this <code>JSplitPane</code>.
	*/
	protected String paramString() {
	String orientationString = (orientation == HORIZONTAL_SPLIT ?
	"HORIZONTAL_SPLIT" : "VERTICAL_SPLIT");
	String continuousLayoutString = (continuousLayout ?
	"true" : "false");
	String oneTouchExpandableString = (oneTouchExpandable ?
	"true" : "false");

	return super.paramString() +
	",continuousLayout=" + continuousLayoutString +
	",dividerSize=" + dividerSize +
	",lastDividerLocation=" + lastDividerLocation +
	",oneTouchExpandable=" + oneTouchExpandableString +
	",orientation=" + orientationString;
	}



	///////////////////////////
	// Accessibility support //
	///////////////////////////


	/**
	* Gets the AccessibleContext associated with this JSplitPane.
	* For split panes, the AccessibleContext takes the form of an
	* AccessibleJSplitPane.
	* A new AccessibleJSplitPane instance is created if necessary.
	*
	* @return an AccessibleJSplitPane that serves as the
	* AccessibleContext of this JSplitPane
	* @beaninfo
	* expert: true
	* description: The AccessibleContext associated with this SplitPane.
	*/
	public AccessibleContext getAccessibleContext() {
	if (accessibleContext == null) {
	accessibleContext = new AccessibleJSplitPane();
	}
	return accessibleContext;
	}


	/**
	* This class implements accessibility support for the
	* <code>JSplitPane</code> class. It provides an implementation of the
	* Java Accessibility API appropriate to split pane user-interface elements.
	* <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}.
	*/
	protected class AccessibleJSplitPane extends AccessibleJComponent
	implements AccessibleValue {
	/**
	* Gets the state set of this object.
	*
	* @return an instance of AccessibleState containing the current state
	* of the object
	* @see AccessibleState
	*/
	public AccessibleStateSet getAccessibleStateSet() {
	AccessibleStateSet states = super.getAccessibleStateSet();
	// FIXME: [[[WDW - Should also add BUSY if this implements
	// Adjustable at some point. If this happens, we probably
	// should also add actions.]]]
	if (getOrientation() == VERTICAL_SPLIT) {
	states.add(AccessibleState.VERTICAL);
	} else {
	states.add(AccessibleState.HORIZONTAL);
	}
	return states;
	}


	/**
	* Get the AccessibleValue associated with this object. In the
	* implementation of the Java Accessibility API for this class,
	* return this object, which is responsible for implementing the
	* AccessibleValue interface on behalf of itself.
	*
	* @return this object
	*/
	public AccessibleValue getAccessibleValue() {
	return this;
	}


	/**
	* Gets the accessible value of this object.
	*
	* @return a localized String describing the value of this object
	*/
	public Number getCurrentAccessibleValue() {
	return Integer.valueOf(getDividerLocation());
	}


	/**
	* Sets the value of this object as a Number.
	*
	* @return True if the value was set.
	*/
	public boolean setCurrentAccessibleValue(Number n) {
	// TIGER - 4422535
	if (n == null) {
	return false;
	}
	setDividerLocation(n.intValue());
	return true;
	}


	/**
	* Gets the minimum accessible value of this object.
	*
	* @return The minimum value of this object.
	*/
	public Number getMinimumAccessibleValue() {
	return Integer.valueOf(getUI().getMinimumDividerLocation(
	JSplitPane.this));
	}


	/**
	* Gets the maximum accessible value of this object.
	*
	* @return The maximum value of this object.
	*/
	public Number getMaximumAccessibleValue() {
	return Integer.valueOf(getUI().getMaximumDividerLocation(
	JSplitPane.this));
	}


	/**
	* Gets the role of this object.
	*
	* @return an instance of AccessibleRole describing the role of
	* the object
	* @see AccessibleRole
	*/
	public AccessibleRole getAccessibleRole() {
	return AccessibleRole.SPLIT_PANE;
	}
	} // inner class AccessibleJSplitPane
	}

Back to index...