1255 lines
41 KiB
Java
1255 lines
41 KiB
Java
/*
|
|
* Copyright 1997-2008 Sun Microsystems, Inc. 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. Sun designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
|
* CA 95054 USA or visit www.sun.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="http://java.sun.com/docs/books/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<sup><font size="-2">TM</font></sup>
|
|
* 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 with no continuous
|
|
* layout, 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 and no continuous layout.
|
|
*
|
|
* @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
|
|
* with the specified components that do not do continuous
|
|
* redrawing.
|
|
*
|
|
* @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 <code>false</code>.
|
|
* 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 curent 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
|
|
*
|
|
* @beaninfo
|
|
* hidden: true
|
|
*/
|
|
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<sup><font size="-2">TM</font></sup>
|
|
* 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
|
|
}
|