8043548: Fix raw and unchecked lint warnings in javax.swing.plaf.*
8042849: Fix raw and unchecked warnings in com.sun.java.swing
Reviewed-by: pchelko, alexsch
/*
* Copyright (c) 1997, 2014, 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.plaf.basic;
import sun.swing.DefaultLookup;
import sun.swing.UIAction;
import javax.swing.*;
import javax.swing.border.Border;
import java.awt.*;
import java.awt.event.*;
import java.awt.peer.ComponentPeer;
import java.awt.peer.LightweightPeer;
import java.beans.*;
import java.util.*;
import javax.swing.plaf.SplitPaneUI;
import javax.swing.plaf.ComponentUI;
import javax.swing.plaf.UIResource;
import sun.swing.SwingUtilities2;
/**
* A Basic L&F implementation of the SplitPaneUI.
*
* @author Scott Violet
* @author Steve Wilson
* @author Ralph Kar
*/
public class BasicSplitPaneUI extends SplitPaneUI
{
/**
* The divider used for non-continuous layout is added to the split pane
* with this object.
*/
protected static final String NON_CONTINUOUS_DIVIDER =
"nonContinuousDivider";
/**
* How far (relative) the divider does move when it is moved around by
* the cursor keys on the keyboard.
*/
protected static int KEYBOARD_DIVIDER_MOVE_OFFSET = 3;
/**
* JSplitPane instance this instance is providing
* the look and feel for.
*/
protected JSplitPane splitPane;
/**
* LayoutManager that is created and placed into the split pane.
*/
protected BasicHorizontalLayoutManager layoutManager;
/**
* Instance of the divider for this JSplitPane.
*/
protected BasicSplitPaneDivider divider;
/**
* Instance of the PropertyChangeListener for this JSplitPane.
*/
protected PropertyChangeListener propertyChangeListener;
/**
* Instance of the FocusListener for this JSplitPane.
*/
protected FocusListener focusListener;
private Handler handler;
/**
* Keys to use for forward focus traversal when the JComponent is
* managing focus.
*/
private Set<KeyStroke> managingFocusForwardTraversalKeys;
/**
* Keys to use for backward focus traversal when the JComponent is
* managing focus.
*/
private Set<KeyStroke> managingFocusBackwardTraversalKeys;
/**
* The size of the divider while the dragging session is valid.
*/
protected int dividerSize;
/**
* Instance for the shadow of the divider when non continuous layout
* is being used.
*/
protected Component nonContinuousLayoutDivider;
/**
* Set to true in startDragging if any of the children
* (not including the nonContinuousLayoutDivider) are heavy weights.
*/
protected boolean draggingHW;
/**
* Location of the divider when the dragging session began.
*/
protected int beginDragDividerLocation;
/**
* As of Java 2 platform v1.3 this previously undocumented field is no
* longer used.
* Key bindings are now defined by the LookAndFeel, please refer to
* the key bindings specification for further details.
*
* @deprecated As of Java 2 platform v1.3.
*/
@Deprecated
protected KeyStroke upKey;
/**
* As of Java 2 platform v1.3 this previously undocumented field is no
* longer used.
* Key bindings are now defined by the LookAndFeel, please refer to
* the key bindings specification for further details.
*
* @deprecated As of Java 2 platform v1.3.
*/
@Deprecated
protected KeyStroke downKey;
/**
* As of Java 2 platform v1.3 this previously undocumented field is no
* longer used.
* Key bindings are now defined by the LookAndFeel, please refer to
* the key bindings specification for further details.
*
* @deprecated As of Java 2 platform v1.3.
*/
@Deprecated
protected KeyStroke leftKey;
/**
* As of Java 2 platform v1.3 this previously undocumented field is no
* longer used.
* Key bindings are now defined by the LookAndFeel, please refer to
* the key bindings specification for further details.
*
* @deprecated As of Java 2 platform v1.3.
*/
@Deprecated
protected KeyStroke rightKey;
/**
* As of Java 2 platform v1.3 this previously undocumented field is no
* longer used.
* Key bindings are now defined by the LookAndFeel, please refer to
* the key bindings specification for further details.
*
* @deprecated As of Java 2 platform v1.3.
*/
@Deprecated
protected KeyStroke homeKey;
/**
* As of Java 2 platform v1.3 this previously undocumented field is no
* longer used.
* Key bindings are now defined by the LookAndFeel, please refer to
* the key bindings specification for further details.
*
* @deprecated As of Java 2 platform v1.3.
*/
@Deprecated
protected KeyStroke endKey;
/**
* As of Java 2 platform v1.3 this previously undocumented field is no
* longer used.
* Key bindings are now defined by the LookAndFeel, please refer to
* the key bindings specification for further details.
*
* @deprecated As of Java 2 platform v1.3.
*/
@Deprecated
protected KeyStroke dividerResizeToggleKey;
/**
* As of Java 2 platform v1.3 this previously undocumented field is no
* longer used.
* Key bindings are now defined by the LookAndFeel, please refer to
* the key bindings specification for further details.
*
* @deprecated As of Java 2 platform v1.3.
*/
@Deprecated
protected ActionListener keyboardUpLeftListener;
/**
* As of Java 2 platform v1.3 this previously undocumented field is no
* longer used.
* Key bindings are now defined by the LookAndFeel, please refer to
* the key bindings specification for further details.
*
* @deprecated As of Java 2 platform v1.3.
*/
@Deprecated
protected ActionListener keyboardDownRightListener;
/**
* As of Java 2 platform v1.3 this previously undocumented field is no
* longer used.
* Key bindings are now defined by the LookAndFeel, please refer to
* the key bindings specification for further details.
*
* @deprecated As of Java 2 platform v1.3.
*/
@Deprecated
protected ActionListener keyboardHomeListener;
/**
* As of Java 2 platform v1.3 this previously undocumented field is no
* longer used.
* Key bindings are now defined by the LookAndFeel, please refer to
* the key bindings specification for further details.
*
* @deprecated As of Java 2 platform v1.3.
*/
@Deprecated
protected ActionListener keyboardEndListener;
/**
* As of Java 2 platform v1.3 this previously undocumented field is no
* longer used.
* Key bindings are now defined by the LookAndFeel, please refer to
* the key bindings specification for further details.
*
* @deprecated As of Java 2 platform v1.3.
*/
@Deprecated
protected ActionListener keyboardResizeToggleListener;
// Private data of the instance
private int orientation;
private int lastDragLocation;
private boolean continuousLayout;
private boolean dividerKeyboardResize;
private boolean dividerLocationIsSet; // needed for tracking
// the first occurrence of
// setDividerLocation()
private Color dividerDraggingColor;
private boolean rememberPaneSizes;
// Indicates whether the one of splitpane sides is expanded
private boolean keepHidden = false;
/** Indicates that we have painted once. */
// This is used by the LayoutManager to determine when it should use
// the divider location provided by the JSplitPane. This is used as there
// is no way to determine when the layout process has completed.
boolean painted;
/** If true, setDividerLocation does nothing. */
boolean ignoreDividerLocationChange;
/**
* Creates a new BasicSplitPaneUI instance
*/
public static ComponentUI createUI(JComponent x) {
return new BasicSplitPaneUI();
}
static void loadActionMap(LazyActionMap map) {
map.put(new Actions(Actions.NEGATIVE_INCREMENT));
map.put(new Actions(Actions.POSITIVE_INCREMENT));
map.put(new Actions(Actions.SELECT_MIN));
map.put(new Actions(Actions.SELECT_MAX));
map.put(new Actions(Actions.START_RESIZE));
map.put(new Actions(Actions.TOGGLE_FOCUS));
map.put(new Actions(Actions.FOCUS_OUT_FORWARD));
map.put(new Actions(Actions.FOCUS_OUT_BACKWARD));
}
/**
* Installs the UI.
*/
public void installUI(JComponent c) {
splitPane = (JSplitPane) c;
dividerLocationIsSet = false;
dividerKeyboardResize = false;
keepHidden = false;
installDefaults();
installListeners();
installKeyboardActions();
setLastDragLocation(-1);
}
/**
* Installs the UI defaults.
*/
protected void installDefaults(){
LookAndFeel.installBorder(splitPane, "SplitPane.border");
LookAndFeel.installColors(splitPane, "SplitPane.background",
"SplitPane.foreground");
LookAndFeel.installProperty(splitPane, "opaque", Boolean.TRUE);
if (divider == null) divider = createDefaultDivider();
divider.setBasicSplitPaneUI(this);
Border b = divider.getBorder();
if (b == null || !(b instanceof UIResource)) {
divider.setBorder(UIManager.getBorder("SplitPaneDivider.border"));
}
dividerDraggingColor = UIManager.getColor("SplitPaneDivider.draggingColor");
setOrientation(splitPane.getOrientation());
// note: don't rename this temp variable to dividerSize
// since it will conflict with "this.dividerSize" field
Integer temp = (Integer)UIManager.get("SplitPane.dividerSize");
LookAndFeel.installProperty(splitPane, "dividerSize", temp == null? 10: temp);
divider.setDividerSize(splitPane.getDividerSize());
dividerSize = divider.getDividerSize();
splitPane.add(divider, JSplitPane.DIVIDER);
setContinuousLayout(splitPane.isContinuousLayout());
resetLayoutManager();
/* Install the nonContinuousLayoutDivider here to avoid having to
add/remove everything later. */
if(nonContinuousLayoutDivider == null) {
setNonContinuousLayoutDivider(
createDefaultNonContinuousLayoutDivider(),
true);
} else {
setNonContinuousLayoutDivider(nonContinuousLayoutDivider, true);
}
// focus forward traversal key
if (managingFocusForwardTraversalKeys==null) {
managingFocusForwardTraversalKeys = new HashSet<KeyStroke>();
managingFocusForwardTraversalKeys.add(
KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0));
}
splitPane.setFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS,
managingFocusForwardTraversalKeys);
// focus backward traversal key
if (managingFocusBackwardTraversalKeys==null) {
managingFocusBackwardTraversalKeys = new HashSet<KeyStroke>();
managingFocusBackwardTraversalKeys.add(
KeyStroke.getKeyStroke(KeyEvent.VK_TAB, InputEvent.SHIFT_MASK));
}
splitPane.setFocusTraversalKeys(KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS,
managingFocusBackwardTraversalKeys);
}
/**
* Installs the event listeners for the UI.
*/
protected void installListeners() {
if ((propertyChangeListener = createPropertyChangeListener()) !=
null) {
splitPane.addPropertyChangeListener(propertyChangeListener);
}
if ((focusListener = createFocusListener()) != null) {
splitPane.addFocusListener(focusListener);
}
}
/**
* Installs the keyboard actions for the UI.
*/
protected void installKeyboardActions() {
InputMap km = getInputMap(JComponent.
WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
SwingUtilities.replaceUIInputMap(splitPane, JComponent.
WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,
km);
LazyActionMap.installLazyActionMap(splitPane, BasicSplitPaneUI.class,
"SplitPane.actionMap");
}
InputMap getInputMap(int condition) {
if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT) {
return (InputMap)DefaultLookup.get(splitPane, this,
"SplitPane.ancestorInputMap");
}
return null;
}
/**
* Uninstalls the UI.
*/
public void uninstallUI(JComponent c) {
uninstallKeyboardActions();
uninstallListeners();
uninstallDefaults();
dividerLocationIsSet = false;
dividerKeyboardResize = false;
splitPane = null;
}
/**
* Uninstalls the UI defaults.
*/
protected void uninstallDefaults() {
if(splitPane.getLayout() == layoutManager) {
splitPane.setLayout(null);
}
if(nonContinuousLayoutDivider != null) {
splitPane.remove(nonContinuousLayoutDivider);
}
LookAndFeel.uninstallBorder(splitPane);
Border b = divider.getBorder();
if (b instanceof UIResource) {
divider.setBorder(null);
}
splitPane.remove(divider);
divider.setBasicSplitPaneUI(null);
layoutManager = null;
divider = null;
nonContinuousLayoutDivider = null;
setNonContinuousLayoutDivider(null);
// sets the focus forward and backward traversal keys to null
// to restore the defaults
splitPane.setFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, null);
splitPane.setFocusTraversalKeys(KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, null);
}
/**
* Uninstalls the event listeners for the UI.
*/
protected void uninstallListeners() {
if (propertyChangeListener != null) {
splitPane.removePropertyChangeListener(propertyChangeListener);
propertyChangeListener = null;
}
if (focusListener != null) {
splitPane.removeFocusListener(focusListener);
focusListener = null;
}
keyboardUpLeftListener = null;
keyboardDownRightListener = null;
keyboardHomeListener = null;
keyboardEndListener = null;
keyboardResizeToggleListener = null;
handler = null;
}
/**
* Uninstalls the keyboard actions for the UI.
*/
protected void uninstallKeyboardActions() {
SwingUtilities.replaceUIActionMap(splitPane, null);
SwingUtilities.replaceUIInputMap(splitPane, JComponent.
WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,
null);
}
/**
* Creates a PropertyChangeListener for the JSplitPane UI.
*/
protected PropertyChangeListener createPropertyChangeListener() {
return getHandler();
}
private Handler getHandler() {
if (handler == null) {
handler = new Handler();
}
return handler;
}
/**
* Creates a FocusListener for the JSplitPane UI.
*/
protected FocusListener createFocusListener() {
return getHandler();
}
/**
* As of Java 2 platform v1.3 this method is no
* longer used. Subclassers previously using this method should
* instead create an Action wrapping the ActionListener, and register
* that Action by overriding <code>installKeyboardActions</code> and
* placing the Action in the SplitPane's ActionMap. Please refer to
* the key bindings specification for further details.
* <p>
* Creates a ActionListener for the JSplitPane UI that listens for
* specific key presses.
*
* @deprecated As of Java 2 platform v1.3.
*/
@Deprecated
protected ActionListener createKeyboardUpLeftListener() {
return new KeyboardUpLeftHandler();
}
/**
* As of Java 2 platform v1.3 this method is no
* longer used. Subclassers previously using this method should
* instead create an Action wrapping the ActionListener, and register
* that Action by overriding <code>installKeyboardActions</code> and
* placing the Action in the SplitPane's ActionMap. Please refer to
* the key bindings specification for further details.
* <p>
* Creates a ActionListener for the JSplitPane UI that listens for
* specific key presses.
*
* @deprecated As of Java 2 platform v1.3.
*/
@Deprecated
protected ActionListener createKeyboardDownRightListener() {
return new KeyboardDownRightHandler();
}
/**
* As of Java 2 platform v1.3 this method is no
* longer used. Subclassers previously using this method should
* instead create an Action wrapping the ActionListener, and register
* that Action by overriding <code>installKeyboardActions</code> and
* placing the Action in the SplitPane's ActionMap. Please refer to
* the key bindings specification for further details.
* <p>
* Creates a ActionListener for the JSplitPane UI that listens for
* specific key presses.
*
* @deprecated As of Java 2 platform v1.3.
*/
@Deprecated
protected ActionListener createKeyboardHomeListener() {
return new KeyboardHomeHandler();
}
/**
* As of Java 2 platform v1.3 this method is no
* longer used. Subclassers previously using this method should
* instead create an Action wrapping the ActionListener, and register
* that Action by overriding <code>installKeyboardActions</code> and
* placing the Action in the SplitPane's ActionMap. Please refer to
* the key bindings specification for further details.
* <p>
* Creates a ActionListener for the JSplitPane UI that listens for
* specific key presses.
*
* @deprecated As of Java 2 platform v1.3.
*/
@Deprecated
protected ActionListener createKeyboardEndListener() {
return new KeyboardEndHandler();
}
/**
* As of Java 2 platform v1.3 this method is no
* longer used. Subclassers previously using this method should
* instead create an Action wrapping the ActionListener, and register
* that Action by overriding <code>installKeyboardActions</code> and
* placing the Action in the SplitPane's ActionMap. Please refer to
* the key bindings specification for further details.
* <p>
* Creates a ActionListener for the JSplitPane UI that listens for
* specific key presses.
*
* @deprecated As of Java 2 platform v1.3.
*/
@Deprecated
protected ActionListener createKeyboardResizeToggleListener() {
return new KeyboardResizeToggleHandler();
}
/**
* Returns the orientation for the JSplitPane.
*/
public int getOrientation() {
return orientation;
}
/**
* Set the orientation for the JSplitPane.
*/
public void setOrientation(int orientation) {
this.orientation = orientation;
}
/**
* Determines whether the JSplitPane is set to use a continuous layout.
*/
public boolean isContinuousLayout() {
return continuousLayout;
}
/**
* Turn continuous layout on/off.
*/
public void setContinuousLayout(boolean b) {
continuousLayout = b;
}
/**
* Returns the last drag location of the JSplitPane.
*/
public int getLastDragLocation() {
return lastDragLocation;
}
/**
* Set the last drag location of the JSplitPane.
*/
public void setLastDragLocation(int l) {
lastDragLocation = l;
}
/**
* @return increment via keyboard methods.
*/
int getKeyboardMoveIncrement() {
return 3;
}
/**
* Implementation of the PropertyChangeListener
* that the JSplitPane UI uses.
* <p>
* This class should be treated as a "protected" inner class.
* Instantiate it only within subclasses of BasicSplitPaneUI.
*/
public class PropertyHandler implements PropertyChangeListener
{
// NOTE: This class exists only for backward compatibility. All
// its functionality has been moved into Handler. If you need to add
// new functionality add it to the Handler, but make sure this
// class calls into the Handler.
/**
* Messaged from the <code>JSplitPane</code> the receiver is
* contained in. May potentially reset the layout manager and cause a
* <code>validate</code> to be sent.
*/
public void propertyChange(PropertyChangeEvent e) {
getHandler().propertyChange(e);
}
}
/**
* Implementation of the FocusListener that the JSplitPane UI uses.
* <p>
* This class should be treated as a "protected" inner class.
* Instantiate it only within subclasses of BasicSplitPaneUI.
*/
public class FocusHandler extends FocusAdapter
{
// NOTE: This class exists only for backward compatibility. All
// its functionality has been moved into Handler. If you need to add
// new functionality add it to the Handler, but make sure this
// class calls into the Handler.
public void focusGained(FocusEvent ev) {
getHandler().focusGained(ev);
}
public void focusLost(FocusEvent ev) {
getHandler().focusLost(ev);
}
}
/**
* Implementation of an ActionListener that the JSplitPane UI uses for
* handling specific key presses.
* <p>
* This class should be treated as a "protected" inner class.
* Instantiate it only within subclasses of BasicSplitPaneUI.
*/
public class KeyboardUpLeftHandler implements ActionListener
{
public void actionPerformed(ActionEvent ev) {
if (dividerKeyboardResize) {
splitPane.setDividerLocation(Math.max(0,getDividerLocation
(splitPane) - getKeyboardMoveIncrement()));
}
}
}
/**
* Implementation of an ActionListener that the JSplitPane UI uses for
* handling specific key presses.
* <p>
* This class should be treated as a "protected" inner class.
* Instantiate it only within subclasses of BasicSplitPaneUI.
*/
public class KeyboardDownRightHandler implements ActionListener
{
public void actionPerformed(ActionEvent ev) {
if (dividerKeyboardResize) {
splitPane.setDividerLocation(getDividerLocation(splitPane) +
getKeyboardMoveIncrement());
}
}
}
/**
* Implementation of an ActionListener that the JSplitPane UI uses for
* handling specific key presses.
* <p>
* This class should be treated as a "protected" inner class.
* Instantiate it only within subclasses of BasicSplitPaneUI.
*/
public class KeyboardHomeHandler implements ActionListener
{
public void actionPerformed(ActionEvent ev) {
if (dividerKeyboardResize) {
splitPane.setDividerLocation(0);
}
}
}
/**
* Implementation of an ActionListener that the JSplitPane UI uses for
* handling specific key presses.
* <p>
* This class should be treated as a "protected" inner class.
* Instantiate it only within subclasses of BasicSplitPaneUI.
*/
public class KeyboardEndHandler implements ActionListener
{
public void actionPerformed(ActionEvent ev) {
if (dividerKeyboardResize) {
Insets insets = splitPane.getInsets();
int bottomI = (insets != null) ? insets.bottom : 0;
int rightI = (insets != null) ? insets.right : 0;
if (orientation == JSplitPane.VERTICAL_SPLIT) {
splitPane.setDividerLocation(splitPane.getHeight() -
bottomI);
}
else {
splitPane.setDividerLocation(splitPane.getWidth() -
rightI);
}
}
}
}
/**
* Implementation of an ActionListener that the JSplitPane UI uses for
* handling specific key presses.
* <p>
* This class should be treated as a "protected" inner class.
* Instantiate it only within subclasses of BasicSplitPaneUI.
*/
public class KeyboardResizeToggleHandler implements ActionListener
{
public void actionPerformed(ActionEvent ev) {
if (!dividerKeyboardResize) {
splitPane.requestFocus();
}
}
}
/**
* Returns the divider between the top Components.
*/
public BasicSplitPaneDivider getDivider() {
return divider;
}
/**
* Returns the default non continuous layout divider, which is an
* instance of {@code Canvas} that fills in the background with dark gray.
*/
@SuppressWarnings("serial") // anonymous class
protected Component createDefaultNonContinuousLayoutDivider() {
return new Canvas() {
public void paint(Graphics g) {
if(!isContinuousLayout() && getLastDragLocation() != -1) {
Dimension size = splitPane.getSize();
g.setColor(dividerDraggingColor);
if(orientation == JSplitPane.HORIZONTAL_SPLIT) {
g.fillRect(0, 0, dividerSize - 1, size.height - 1);
} else {
g.fillRect(0, 0, size.width - 1, dividerSize - 1);
}
}
}
};
}
/**
* Sets the divider to use when the splitPane is configured to
* not continuously layout. This divider will only be used during a
* dragging session. It is recommended that the passed in component
* be a heavy weight.
*/
protected void setNonContinuousLayoutDivider(Component newDivider) {
setNonContinuousLayoutDivider(newDivider, true);
}
/**
* Sets the divider to use.
*/
protected void setNonContinuousLayoutDivider(Component newDivider,
boolean rememberSizes) {
rememberPaneSizes = rememberSizes;
if(nonContinuousLayoutDivider != null && splitPane != null) {
splitPane.remove(nonContinuousLayoutDivider);
}
nonContinuousLayoutDivider = newDivider;
}
private void addHeavyweightDivider() {
if(nonContinuousLayoutDivider != null && splitPane != null) {
/* Needs to remove all the components and re-add them! YECK! */
// This is all done so that the nonContinuousLayoutDivider will
// be drawn on top of the other components, without this, one
// of the heavyweights will draw over the divider!
Component leftC = splitPane.getLeftComponent();
Component rightC = splitPane.getRightComponent();
int lastLocation = splitPane.
getDividerLocation();
if(leftC != null)
splitPane.setLeftComponent(null);
if(rightC != null)
splitPane.setRightComponent(null);
splitPane.remove(divider);
splitPane.add(nonContinuousLayoutDivider, BasicSplitPaneUI.
NON_CONTINUOUS_DIVIDER,
splitPane.getComponentCount());
splitPane.setLeftComponent(leftC);
splitPane.setRightComponent(rightC);
splitPane.add(divider, JSplitPane.DIVIDER);
if(rememberPaneSizes) {
splitPane.setDividerLocation(lastLocation);
}
}
}
/**
* Returns the divider to use when the splitPane is configured to
* not continuously layout. This divider will only be used during a
* dragging session.
*/
public Component getNonContinuousLayoutDivider() {
return nonContinuousLayoutDivider;
}
/**
* Returns the splitpane this instance is currently contained
* in.
*/
public JSplitPane getSplitPane() {
return splitPane;
}
/**
* Creates the default divider.
*/
public BasicSplitPaneDivider createDefaultDivider() {
return new BasicSplitPaneDivider(this);
}
/**
* Messaged to reset the preferred sizes.
*/
public void resetToPreferredSizes(JSplitPane jc) {
if(splitPane != null) {
layoutManager.resetToPreferredSizes();
splitPane.revalidate();
splitPane.repaint();
}
}
/**
* Sets the location of the divider to location.
*/
public void setDividerLocation(JSplitPane jc, int location) {
if (!ignoreDividerLocationChange) {
dividerLocationIsSet = true;
splitPane.revalidate();
splitPane.repaint();
if (keepHidden) {
Insets insets = splitPane.getInsets();
int orientation = splitPane.getOrientation();
if ((orientation == JSplitPane.VERTICAL_SPLIT &&
location != insets.top &&
location != splitPane.getHeight()-divider.getHeight()-insets.top) ||
(orientation == JSplitPane.HORIZONTAL_SPLIT &&
location != insets.left &&
location != splitPane.getWidth()-divider.getWidth()-insets.left)) {
setKeepHidden(false);
}
}
}
else {
ignoreDividerLocationChange = false;
}
}
/**
* Returns the location of the divider, which may differ from what
* the splitpane thinks the location of the divider is.
*/
public int getDividerLocation(JSplitPane jc) {
if(orientation == JSplitPane.HORIZONTAL_SPLIT)
return divider.getLocation().x;
return divider.getLocation().y;
}
/**
* Gets the minimum location of the divider.
*/
public int getMinimumDividerLocation(JSplitPane jc) {
int minLoc = 0;
Component leftC = splitPane.getLeftComponent();
if ((leftC != null) && (leftC.isVisible())) {
Insets insets = splitPane.getInsets();
Dimension minSize = leftC.getMinimumSize();
if(orientation == JSplitPane.HORIZONTAL_SPLIT) {
minLoc = minSize.width;
} else {
minLoc = minSize.height;
}
if(insets != null) {
if(orientation == JSplitPane.HORIZONTAL_SPLIT) {
minLoc += insets.left;
} else {
minLoc += insets.top;
}
}
}
return minLoc;
}
/**
* Gets the maximum location of the divider.
*/
public int getMaximumDividerLocation(JSplitPane jc) {
Dimension splitPaneSize = splitPane.getSize();
int maxLoc = 0;
Component rightC = splitPane.getRightComponent();
if (rightC != null) {
Insets insets = splitPane.getInsets();
Dimension minSize = new Dimension(0, 0);
if (rightC.isVisible()) {
minSize = rightC.getMinimumSize();
}
if(orientation == JSplitPane.HORIZONTAL_SPLIT) {
maxLoc = splitPaneSize.width - minSize.width;
} else {
maxLoc = splitPaneSize.height - minSize.height;
}
maxLoc -= dividerSize;
if(insets != null) {
if(orientation == JSplitPane.HORIZONTAL_SPLIT) {
maxLoc -= insets.right;
} else {
maxLoc -= insets.top;
}
}
}
return Math.max(getMinimumDividerLocation(splitPane), maxLoc);
}
/**
* Called when the specified split pane has finished painting
* its children.
*/
public void finishedPaintingChildren(JSplitPane sp, Graphics g) {
if(sp == splitPane && getLastDragLocation() != -1 &&
!isContinuousLayout() && !draggingHW) {
Dimension size = splitPane.getSize();
g.setColor(dividerDraggingColor);
if(orientation == JSplitPane.HORIZONTAL_SPLIT) {
g.fillRect(getLastDragLocation(), 0, dividerSize - 1,
size.height - 1);
} else {
g.fillRect(0, lastDragLocation, size.width - 1,
dividerSize - 1);
}
}
}
/**
* {@inheritDoc}
*/
public void paint(Graphics g, JComponent jc) {
if (!painted && splitPane.getDividerLocation()<0) {
ignoreDividerLocationChange = true;
splitPane.setDividerLocation(getDividerLocation(splitPane));
}
painted = true;
}
/**
* Returns the preferred size for the passed in component,
* This is passed off to the current layout manager.
*/
public Dimension getPreferredSize(JComponent jc) {
if(splitPane != null)
return layoutManager.preferredLayoutSize(splitPane);
return new Dimension(0, 0);
}
/**
* Returns the minimum size for the passed in component,
* This is passed off to the current layout manager.
*/
public Dimension getMinimumSize(JComponent jc) {
if(splitPane != null)
return layoutManager.minimumLayoutSize(splitPane);
return new Dimension(0, 0);
}
/**
* Returns the maximum size for the passed in component,
* This is passed off to the current layout manager.
*/
public Dimension getMaximumSize(JComponent jc) {
if(splitPane != null)
return layoutManager.maximumLayoutSize(splitPane);
return new Dimension(0, 0);
}
/**
* Returns the insets. The insets are returned from the border insets
* of the current border.
*/
public Insets getInsets(JComponent jc) {
return null;
}
/**
* Resets the layout manager based on orientation and messages it
* with invalidateLayout to pull in appropriate Components.
*/
protected void resetLayoutManager() {
if(orientation == JSplitPane.HORIZONTAL_SPLIT) {
layoutManager = new BasicHorizontalLayoutManager(0);
} else {
layoutManager = new BasicHorizontalLayoutManager(1);
}
splitPane.setLayout(layoutManager);
layoutManager.updateComponents();
splitPane.revalidate();
splitPane.repaint();
}
/**
* Set the value to indicate if one of the splitpane sides is expanded.
*/
void setKeepHidden(boolean keepHidden) {
this.keepHidden = keepHidden;
}
/**
* The value returned indicates if one of the splitpane sides is expanded.
* @return true if one of the splitpane sides is expanded, false otherwise.
*/
private boolean getKeepHidden() {
return keepHidden;
}
/**
* Should be messaged before the dragging session starts, resets
* lastDragLocation and dividerSize.
*/
protected void startDragging() {
Component leftC = splitPane.getLeftComponent();
Component rightC = splitPane.getRightComponent();
ComponentPeer cPeer;
beginDragDividerLocation = getDividerLocation(splitPane);
draggingHW = false;
if(leftC != null && (cPeer = leftC.getPeer()) != null &&
!(cPeer instanceof LightweightPeer)) {
draggingHW = true;
} else if(rightC != null && (cPeer = rightC.getPeer()) != null
&& !(cPeer instanceof LightweightPeer)) {
draggingHW = true;
}
if(orientation == JSplitPane.HORIZONTAL_SPLIT) {
setLastDragLocation(divider.getBounds().x);
dividerSize = divider.getSize().width;
if(!isContinuousLayout() && draggingHW) {
nonContinuousLayoutDivider.setBounds
(getLastDragLocation(), 0, dividerSize,
splitPane.getHeight());
addHeavyweightDivider();
}
} else {
setLastDragLocation(divider.getBounds().y);
dividerSize = divider.getSize().height;
if(!isContinuousLayout() && draggingHW) {
nonContinuousLayoutDivider.setBounds
(0, getLastDragLocation(), splitPane.getWidth(),
dividerSize);
addHeavyweightDivider();
}
}
}
/**
* Messaged during a dragging session to move the divider to the
* passed in location. If continuousLayout is true the location is
* reset and the splitPane validated.
*/
protected void dragDividerTo(int location) {
if(getLastDragLocation() != location) {
if(isContinuousLayout()) {
splitPane.setDividerLocation(location);
setLastDragLocation(location);
} else {
int lastLoc = getLastDragLocation();
setLastDragLocation(location);
if(orientation == JSplitPane.HORIZONTAL_SPLIT) {
if(draggingHW) {
nonContinuousLayoutDivider.setLocation(
getLastDragLocation(), 0);
} else {
int splitHeight = splitPane.getHeight();
splitPane.repaint(lastLoc, 0, dividerSize,
splitHeight);
splitPane.repaint(location, 0, dividerSize,
splitHeight);
}
} else {
if(draggingHW) {
nonContinuousLayoutDivider.setLocation(0,
getLastDragLocation());
} else {
int splitWidth = splitPane.getWidth();
splitPane.repaint(0, lastLoc, splitWidth,
dividerSize);
splitPane.repaint(0, location, splitWidth,
dividerSize);
}
}
}
}
}
/**
* Messaged to finish the dragging session. If not continuous display
* the dividers location will be reset.
*/
protected void finishDraggingTo(int location) {
dragDividerTo(location);
setLastDragLocation(-1);
if(!isContinuousLayout()) {
Component leftC = splitPane.getLeftComponent();
Rectangle leftBounds = leftC.getBounds();
if (draggingHW) {
if(orientation == JSplitPane.HORIZONTAL_SPLIT) {
nonContinuousLayoutDivider.setLocation(-dividerSize, 0);
}
else {
nonContinuousLayoutDivider.setLocation(0, -dividerSize);
}
splitPane.remove(nonContinuousLayoutDivider);
}
splitPane.setDividerLocation(location);
}
}
/**
* As of Java 2 platform v1.3 this method is no longer used. Instead
* you should set the border on the divider.
* <p>
* Returns the width of one side of the divider border.
*
* @deprecated As of Java 2 platform v1.3, instead set the border on the
* divider.
*/
@Deprecated
protected int getDividerBorderSize() {
return 1;
}
/**
* LayoutManager for JSplitPanes that have an orientation of
* HORIZONTAL_SPLIT.
*/
public class BasicHorizontalLayoutManager implements LayoutManager2
{
/* left, right, divider. (in this exact order) */
protected int[] sizes;
protected Component[] components;
/** Size of the splitpane the last time laid out. */
private int lastSplitPaneSize;
/** True if resetToPreferredSizes has been invoked. */
private boolean doReset;
/** Axis, 0 for horizontal, or 1 for veritcal. */
private int axis;
BasicHorizontalLayoutManager() {
this(0);
}
BasicHorizontalLayoutManager(int axis) {
this.axis = axis;
components = new Component[3];
components[0] = components[1] = components[2] = null;
sizes = new int[3];
}
//
// LayoutManager
//
/**
* Does the actual layout.
*/
public void layoutContainer(Container container) {
Dimension containerSize = container.getSize();
// If the splitpane has a zero size then no op out of here.
// If we execute this function now, we're going to cause ourselves
// much grief.
if (containerSize.height <= 0 || containerSize.width <= 0 ) {
lastSplitPaneSize = 0;
return;
}
int spDividerLocation = splitPane.getDividerLocation();
Insets insets = splitPane.getInsets();
int availableSize = getAvailableSize(containerSize,
insets);
int newSize = getSizeForPrimaryAxis(containerSize);
int beginLocation = getDividerLocation(splitPane);
int dOffset = getSizeForPrimaryAxis(insets, true);
Dimension dSize = (components[2] == null) ? null :
components[2].getPreferredSize();
if ((doReset && !dividerLocationIsSet) || spDividerLocation < 0) {
resetToPreferredSizes(availableSize);
}
else if (lastSplitPaneSize <= 0 ||
availableSize == lastSplitPaneSize || !painted ||
(dSize != null &&
getSizeForPrimaryAxis(dSize) != sizes[2])) {
if (dSize != null) {
sizes[2] = getSizeForPrimaryAxis(dSize);
}
else {
sizes[2] = 0;
}
setDividerLocation(spDividerLocation - dOffset, availableSize);
dividerLocationIsSet = false;
}
else if (availableSize != lastSplitPaneSize) {
distributeSpace(availableSize - lastSplitPaneSize,
getKeepHidden());
}
doReset = false;
dividerLocationIsSet = false;
lastSplitPaneSize = availableSize;
// Reset the bounds of each component
int nextLocation = getInitialLocation(insets);
int counter = 0;
while (counter < 3) {
if (components[counter] != null &&
components[counter].isVisible()) {
setComponentToSize(components[counter], sizes[counter],
nextLocation, insets, containerSize);
nextLocation += sizes[counter];
}
switch (counter) {
case 0:
counter = 2;
break;
case 2:
counter = 1;
break;
case 1:
counter = 3;
break;
}
}
if (painted) {
// This is tricky, there is never a good time for us
// to push the value to the splitpane, painted appears to
// the best time to do it. What is really needed is
// notification that layout has completed.
int newLocation = getDividerLocation(splitPane);
if (newLocation != (spDividerLocation - dOffset)) {
int lastLocation = splitPane.getLastDividerLocation();
ignoreDividerLocationChange = true;
try {
splitPane.setDividerLocation(newLocation);
// This is not always needed, but is rather tricky
// to determine when... The case this is needed for
// is if the user sets the divider location to some
// bogus value, say 0, and the actual value is 1, the
// call to setDividerLocation(1) will preserve the
// old value of 0, when we really want the divider
// location value before the call. This is needed for
// the one touch buttons.
splitPane.setLastDividerLocation(lastLocation);
} finally {
ignoreDividerLocationChange = false;
}
}
}
}
/**
* Adds the component at place. Place must be one of
* JSplitPane.LEFT, RIGHT, TOP, BOTTOM, or null (for the
* divider).
*/
public void addLayoutComponent(String place, Component component) {
boolean isValid = true;
if(place != null) {
if(place.equals(JSplitPane.DIVIDER)) {
/* Divider. */
components[2] = component;
sizes[2] = getSizeForPrimaryAxis(component.
getPreferredSize());
} else if(place.equals(JSplitPane.LEFT) ||
place.equals(JSplitPane.TOP)) {
components[0] = component;
sizes[0] = 0;
} else if(place.equals(JSplitPane.RIGHT) ||
place.equals(JSplitPane.BOTTOM)) {
components[1] = component;
sizes[1] = 0;
} else if(!place.equals(
BasicSplitPaneUI.NON_CONTINUOUS_DIVIDER))
isValid = false;
} else {
isValid = false;
}
if(!isValid)
throw new IllegalArgumentException("cannot add to layout: " +
"unknown constraint: " +
place);
doReset = true;
}
/**
* Returns the minimum size needed to contain the children.
* The width is the sum of all the children's min widths and
* the height is the largest of the children's minimum heights.
*/
public Dimension minimumLayoutSize(Container container) {
int minPrimary = 0;
int minSecondary = 0;
Insets insets = splitPane.getInsets();
for (int counter=0; counter<3; counter++) {
if(components[counter] != null) {
Dimension minSize = components[counter].getMinimumSize();
int secSize = getSizeForSecondaryAxis(minSize);
minPrimary += getSizeForPrimaryAxis(minSize);
if(secSize > minSecondary)
minSecondary = secSize;
}
}
if(insets != null) {
minPrimary += getSizeForPrimaryAxis(insets, true) +
getSizeForPrimaryAxis(insets, false);
minSecondary += getSizeForSecondaryAxis(insets, true) +
getSizeForSecondaryAxis(insets, false);
}
if (axis == 0) {
return new Dimension(minPrimary, minSecondary);
}
return new Dimension(minSecondary, minPrimary);
}
/**
* Returns the preferred size needed to contain the children.
* The width is the sum of all the preferred widths of the children and
* the height is the largest preferred height of the children.
*/
public Dimension preferredLayoutSize(Container container) {
int prePrimary = 0;
int preSecondary = 0;
Insets insets = splitPane.getInsets();
for(int counter = 0; counter < 3; counter++) {
if(components[counter] != null) {
Dimension preSize = components[counter].
getPreferredSize();
int secSize = getSizeForSecondaryAxis(preSize);
prePrimary += getSizeForPrimaryAxis(preSize);
if(secSize > preSecondary)
preSecondary = secSize;
}
}
if(insets != null) {
prePrimary += getSizeForPrimaryAxis(insets, true) +
getSizeForPrimaryAxis(insets, false);
preSecondary += getSizeForSecondaryAxis(insets, true) +
getSizeForSecondaryAxis(insets, false);
}
if (axis == 0) {
return new Dimension(prePrimary, preSecondary);
}
return new Dimension(preSecondary, prePrimary);
}
/**
* Removes the specified component from our knowledge.
*/
public void removeLayoutComponent(Component component) {
for(int counter = 0; counter < 3; counter++) {
if(components[counter] == component) {
components[counter] = null;
sizes[counter] = 0;
doReset = true;
}
}
}
//
// LayoutManager2
//
/**
* Adds the specified component to the layout, using the specified
* constraint object.
* @param comp the component to be added
* @param constraints where/how the component is added to the layout.
*/
public void addLayoutComponent(Component comp, Object constraints) {
if ((constraints == null) || (constraints instanceof String)) {
addLayoutComponent((String)constraints, comp);
} else {
throw new IllegalArgumentException("cannot add to layout: " +
"constraint must be a " +
"string (or null)");
}
}
/**
* Returns the alignment along the x axis. This specifies how
* the component would like to be aligned relative to other
* components. The value should be a number between 0 and 1
* where 0 represents alignment along the origin, 1 is aligned
* the furthest away from the origin, 0.5 is centered, etc.
*/
public float getLayoutAlignmentX(Container target) {
return 0.0f;
}
/**
* Returns the alignment along the y axis. This specifies how
* the component would like to be aligned relative to other
* components. The value should be a number between 0 and 1
* where 0 represents alignment along the origin, 1 is aligned
* the furthest away from the origin, 0.5 is centered, etc.
*/
public float getLayoutAlignmentY(Container target) {
return 0.0f;
}
/**
* Does nothing. If the developer really wants to change the
* size of one of the views JSplitPane.resetToPreferredSizes should
* be messaged.
*/
public void invalidateLayout(Container c) {
}
/**
* Returns the maximum layout size, which is Integer.MAX_VALUE
* in both directions.
*/
public Dimension maximumLayoutSize(Container target) {
return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
}
//
// New methods.
//
/**
* Marks the receiver so that the next time this instance is
* laid out it'll ask for the preferred sizes.
*/
public void resetToPreferredSizes() {
doReset = true;
}
/**
* Resets the size of the Component at the passed in location.
*/
protected void resetSizeAt(int index) {
sizes[index] = 0;
doReset = true;
}
/**
* Sets the sizes to <code>newSizes</code>.
*/
protected void setSizes(int[] newSizes) {
System.arraycopy(newSizes, 0, sizes, 0, 3);
}
/**
* Returns the sizes of the components.
*/
protected int[] getSizes() {
int[] retSizes = new int[3];
System.arraycopy(sizes, 0, retSizes, 0, 3);
return retSizes;
}
/**
* Returns the width of the passed in Components preferred size.
*/
protected int getPreferredSizeOfComponent(Component c) {
return getSizeForPrimaryAxis(c.getPreferredSize());
}
/**
* Returns the width of the passed in Components minimum size.
*/
int getMinimumSizeOfComponent(Component c) {
return getSizeForPrimaryAxis(c.getMinimumSize());
}
/**
* Returns the width of the passed in component.
*/
protected int getSizeOfComponent(Component c) {
return getSizeForPrimaryAxis(c.getSize());
}
/**
* Returns the available width based on the container size and
* Insets.
*/
protected int getAvailableSize(Dimension containerSize,
Insets insets) {
if(insets == null)
return getSizeForPrimaryAxis(containerSize);
return (getSizeForPrimaryAxis(containerSize) -
(getSizeForPrimaryAxis(insets, true) +
getSizeForPrimaryAxis(insets, false)));
}
/**
* Returns the left inset, unless the Insets are null in which case
* 0 is returned.
*/
protected int getInitialLocation(Insets insets) {
if(insets != null)
return getSizeForPrimaryAxis(insets, true);
return 0;
}
/**
* Sets the width of the component c to be size, placing its
* x location at location, y to the insets.top and height
* to the containersize.height less the top and bottom insets.
*/
protected void setComponentToSize(Component c, int size,
int location, Insets insets,
Dimension containerSize) {
if(insets != null) {
if (axis == 0) {
c.setBounds(location, insets.top, size,
containerSize.height -
(insets.top + insets.bottom));
}
else {
c.setBounds(insets.left, location, containerSize.width -
(insets.left + insets.right), size);
}
}
else {
if (axis == 0) {
c.setBounds(location, 0, size, containerSize.height);
}
else {
c.setBounds(0, location, containerSize.width, size);
}
}
}
/**
* If the axis == 0, the width is returned, otherwise the height.
*/
int getSizeForPrimaryAxis(Dimension size) {
if (axis == 0) {
return size.width;
}
return size.height;
}
/**
* If the axis == 0, the width is returned, otherwise the height.
*/
int getSizeForSecondaryAxis(Dimension size) {
if (axis == 0) {
return size.height;
}
return size.width;
}
/**
* Returns a particular value of the inset identified by the
* axis and <code>isTop</code><p>
* axis isTop
* 0 true - left
* 0 false - right
* 1 true - top
* 1 false - bottom
*/
int getSizeForPrimaryAxis(Insets insets, boolean isTop) {
if (axis == 0) {
if (isTop) {
return insets.left;
}
return insets.right;
}
if (isTop) {
return insets.top;
}
return insets.bottom;
}
/**
* Returns a particular value of the inset identified by the
* axis and <code>isTop</code><p>
* axis isTop
* 0 true - left
* 0 false - right
* 1 true - top
* 1 false - bottom
*/
int getSizeForSecondaryAxis(Insets insets, boolean isTop) {
if (axis == 0) {
if (isTop) {
return insets.top;
}
return insets.bottom;
}
if (isTop) {
return insets.left;
}
return insets.right;
}
/**
* Determines the components. This should be called whenever
* a new instance of this is installed into an existing
* SplitPane.
*/
protected void updateComponents() {
Component comp;
comp = splitPane.getLeftComponent();
if(components[0] != comp) {
components[0] = comp;
if(comp == null) {
sizes[0] = 0;
} else {
sizes[0] = -1;
}
}
comp = splitPane.getRightComponent();
if(components[1] != comp) {
components[1] = comp;
if(comp == null) {
sizes[1] = 0;
} else {
sizes[1] = -1;
}
}
/* Find the divider. */
Component[] children = splitPane.getComponents();
Component oldDivider = components[2];
components[2] = null;
for(int counter = children.length - 1; counter >= 0; counter--) {
if(children[counter] != components[0] &&
children[counter] != components[1] &&
children[counter] != nonContinuousLayoutDivider) {
if(oldDivider != children[counter]) {
components[2] = children[counter];
} else {
components[2] = oldDivider;
}
break;
}
}
if(components[2] == null) {
sizes[2] = 0;
}
else {
sizes[2] = getSizeForPrimaryAxis(components[2].getPreferredSize());
}
}
/**
* Resets the size of the first component to <code>leftSize</code>,
* and the right component to the remainder of the space.
*/
void setDividerLocation(int leftSize, int availableSize) {
boolean lValid = (components[0] != null &&
components[0].isVisible());
boolean rValid = (components[1] != null &&
components[1].isVisible());
boolean dValid = (components[2] != null &&
components[2].isVisible());
int max = availableSize;
if (dValid) {
max -= sizes[2];
}
leftSize = Math.max(0, Math.min(leftSize, max));
if (lValid) {
if (rValid) {
sizes[0] = leftSize;
sizes[1] = max - leftSize;
}
else {
sizes[0] = max;
sizes[1] = 0;
}
}
else if (rValid) {
sizes[1] = max;
sizes[0] = 0;
}
}
/**
* Returns an array of the minimum sizes of the components.
*/
int[] getPreferredSizes() {
int[] retValue = new int[3];
for (int counter = 0; counter < 3; counter++) {
if (components[counter] != null &&
components[counter].isVisible()) {
retValue[counter] = getPreferredSizeOfComponent
(components[counter]);
}
else {
retValue[counter] = -1;
}
}
return retValue;
}
/**
* Returns an array of the minimum sizes of the components.
*/
int[] getMinimumSizes() {
int[] retValue = new int[3];
for (int counter = 0; counter < 2; counter++) {
if (components[counter] != null &&
components[counter].isVisible()) {
retValue[counter] = getMinimumSizeOfComponent
(components[counter]);
}
else {
retValue[counter] = -1;
}
}
retValue[2] = (components[2] != null) ?
getMinimumSizeOfComponent(components[2]) : -1;
return retValue;
}
/**
* Resets the components to their preferred sizes.
*/
void resetToPreferredSizes(int availableSize) {
// Set the sizes to the preferred sizes (if fits), otherwise
// set to min sizes and distribute any extra space.
int[] testSizes = getPreferredSizes();
int totalSize = 0;
for (int counter = 0; counter < 3; counter++) {
if (testSizes[counter] != -1) {
totalSize += testSizes[counter];
}
}
if (totalSize > availableSize) {
testSizes = getMinimumSizes();
totalSize = 0;
for (int counter = 0; counter < 3; counter++) {
if (testSizes[counter] != -1) {
totalSize += testSizes[counter];
}
}
}
setSizes(testSizes);
distributeSpace(availableSize - totalSize, false);
}
/**
* Distributes <code>space</code> between the two components
* (divider won't get any extra space) based on the weighting. This
* attempts to honor the min size of the components.
*
* @param keepHidden if true and one of the components is 0x0
* it gets none of the extra space
*/
void distributeSpace(int space, boolean keepHidden) {
boolean lValid = (components[0] != null &&
components[0].isVisible());
boolean rValid = (components[1] != null &&
components[1].isVisible());
if (keepHidden) {
if (lValid && getSizeForPrimaryAxis(
components[0].getSize()) == 0) {
lValid = false;
if (rValid && getSizeForPrimaryAxis(
components[1].getSize()) == 0) {
// Both aren't valid, force them both to be valid
lValid = true;
}
}
else if (rValid && getSizeForPrimaryAxis(
components[1].getSize()) == 0) {
rValid = false;
}
}
if (lValid && rValid) {
double weight = splitPane.getResizeWeight();
int lExtra = (int)(weight * (double)space);
int rExtra = (space - lExtra);
sizes[0] += lExtra;
sizes[1] += rExtra;
int lMin = getMinimumSizeOfComponent(components[0]);
int rMin = getMinimumSizeOfComponent(components[1]);
boolean lMinValid = (sizes[0] >= lMin);
boolean rMinValid = (sizes[1] >= rMin);
if (!lMinValid && !rMinValid) {
if (sizes[0] < 0) {
sizes[1] += sizes[0];
sizes[0] = 0;
}
else if (sizes[1] < 0) {
sizes[0] += sizes[1];
sizes[1] = 0;
}
}
else if (!lMinValid) {
if (sizes[1] - (lMin - sizes[0]) < rMin) {
// both below min, just make sure > 0
if (sizes[0] < 0) {
sizes[1] += sizes[0];
sizes[0] = 0;
}
}
else {
sizes[1] -= (lMin - sizes[0]);
sizes[0] = lMin;
}
}
else if (!rMinValid) {
if (sizes[0] - (rMin - sizes[1]) < lMin) {
// both below min, just make sure > 0
if (sizes[1] < 0) {
sizes[0] += sizes[1];
sizes[1] = 0;
}
}
else {
sizes[0] -= (rMin - sizes[1]);
sizes[1] = rMin;
}
}
if (sizes[0] < 0) {
sizes[0] = 0;
}
if (sizes[1] < 0) {
sizes[1] = 0;
}
}
else if (lValid) {
sizes[0] = Math.max(0, sizes[0] + space);
}
else if (rValid) {
sizes[1] = Math.max(0, sizes[1] + space);
}
}
}
/**
* LayoutManager used for JSplitPanes with an orientation of
* VERTICAL_SPLIT.
*
*/
public class BasicVerticalLayoutManager extends
BasicHorizontalLayoutManager
{
public BasicVerticalLayoutManager() {
super(1);
}
}
private class Handler implements FocusListener, PropertyChangeListener {
//
// PropertyChangeListener
//
/**
* Messaged from the <code>JSplitPane</code> the receiver is
* contained in. May potentially reset the layout manager and cause a
* <code>validate</code> to be sent.
*/
public void propertyChange(PropertyChangeEvent e) {
if(e.getSource() == splitPane) {
String changeName = e.getPropertyName();
if(changeName == JSplitPane.ORIENTATION_PROPERTY) {
orientation = splitPane.getOrientation();
resetLayoutManager();
} else if(changeName == JSplitPane.CONTINUOUS_LAYOUT_PROPERTY){
setContinuousLayout(splitPane.isContinuousLayout());
if(!isContinuousLayout()) {
if(nonContinuousLayoutDivider == null) {
setNonContinuousLayoutDivider(
createDefaultNonContinuousLayoutDivider(),
true);
} else if(nonContinuousLayoutDivider.getParent() ==
null) {
setNonContinuousLayoutDivider(
nonContinuousLayoutDivider,
true);
}
}
} else if(changeName == JSplitPane.DIVIDER_SIZE_PROPERTY){
divider.setDividerSize(splitPane.getDividerSize());
dividerSize = divider.getDividerSize();
splitPane.revalidate();
splitPane.repaint();
}
}
}
//
// FocusListener
//
public void focusGained(FocusEvent ev) {
dividerKeyboardResize = true;
splitPane.repaint();
}
public void focusLost(FocusEvent ev) {
dividerKeyboardResize = false;
splitPane.repaint();
}
}
private static class Actions extends UIAction {
private static final String NEGATIVE_INCREMENT = "negativeIncrement";
private static final String POSITIVE_INCREMENT = "positiveIncrement";
private static final String SELECT_MIN = "selectMin";
private static final String SELECT_MAX = "selectMax";
private static final String START_RESIZE = "startResize";
private static final String TOGGLE_FOCUS = "toggleFocus";
private static final String FOCUS_OUT_FORWARD = "focusOutForward";
private static final String FOCUS_OUT_BACKWARD = "focusOutBackward";
Actions(String key) {
super(key);
}
public void actionPerformed(ActionEvent ev) {
JSplitPane splitPane = (JSplitPane)ev.getSource();
BasicSplitPaneUI ui = (BasicSplitPaneUI)BasicLookAndFeel.
getUIOfType(splitPane.getUI(), BasicSplitPaneUI.class);
if (ui == null) {
return;
}
String key = getName();
if (key == NEGATIVE_INCREMENT) {
if (ui.dividerKeyboardResize) {
splitPane.setDividerLocation(Math.max(
0, ui.getDividerLocation
(splitPane) - ui.getKeyboardMoveIncrement()));
}
}
else if (key == POSITIVE_INCREMENT) {
if (ui.dividerKeyboardResize) {
splitPane.setDividerLocation(
ui.getDividerLocation(splitPane) +
ui.getKeyboardMoveIncrement());
}
}
else if (key == SELECT_MIN) {
if (ui.dividerKeyboardResize) {
splitPane.setDividerLocation(0);
}
}
else if (key == SELECT_MAX) {
if (ui.dividerKeyboardResize) {
Insets insets = splitPane.getInsets();
int bottomI = (insets != null) ? insets.bottom : 0;
int rightI = (insets != null) ? insets.right : 0;
if (ui.orientation == JSplitPane.VERTICAL_SPLIT) {
splitPane.setDividerLocation(splitPane.getHeight() -
bottomI);
}
else {
splitPane.setDividerLocation(splitPane.getWidth() -
rightI);
}
}
}
else if (key == START_RESIZE) {
if (!ui.dividerKeyboardResize) {
splitPane.requestFocus();
} else {
JSplitPane parentSplitPane =
(JSplitPane)SwingUtilities.getAncestorOfClass(
JSplitPane.class, splitPane);
if (parentSplitPane!=null) {
parentSplitPane.requestFocus();
}
}
}
else if (key == TOGGLE_FOCUS) {
toggleFocus(splitPane);
}
else if (key == FOCUS_OUT_FORWARD) {
moveFocus(splitPane, 1);
}
else if (key == FOCUS_OUT_BACKWARD) {
moveFocus(splitPane, -1);
}
}
private void moveFocus(JSplitPane splitPane, int direction) {
Container rootAncestor = splitPane.getFocusCycleRootAncestor();
FocusTraversalPolicy policy = rootAncestor.getFocusTraversalPolicy();
Component focusOn = (direction > 0) ?
policy.getComponentAfter(rootAncestor, splitPane) :
policy.getComponentBefore(rootAncestor, splitPane);
HashSet<Component> focusFrom = new HashSet<Component>();
if (splitPane.isAncestorOf(focusOn)) {
do {
focusFrom.add(focusOn);
rootAncestor = focusOn.getFocusCycleRootAncestor();
policy = rootAncestor.getFocusTraversalPolicy();
focusOn = (direction > 0) ?
policy.getComponentAfter(rootAncestor, focusOn) :
policy.getComponentBefore(rootAncestor, focusOn);
} while (splitPane.isAncestorOf(focusOn) &&
!focusFrom.contains(focusOn));
}
if ( focusOn!=null && !splitPane.isAncestorOf(focusOn) ) {
focusOn.requestFocus();
}
}
private void toggleFocus(JSplitPane splitPane) {
Component left = splitPane.getLeftComponent();
Component right = splitPane.getRightComponent();
KeyboardFocusManager manager =
KeyboardFocusManager.getCurrentKeyboardFocusManager();
Component focus = manager.getFocusOwner();
Component focusOn = getNextSide(splitPane, focus);
if (focusOn != null) {
// don't change the focus if the new focused component belongs
// to the same splitpane and the same side
if ( focus!=null &&
( (SwingUtilities.isDescendingFrom(focus, left) &&
SwingUtilities.isDescendingFrom(focusOn, left)) ||
(SwingUtilities.isDescendingFrom(focus, right) &&
SwingUtilities.isDescendingFrom(focusOn, right)) ) ) {
return;
}
SwingUtilities2.compositeRequestFocus(focusOn);
}
}
private Component getNextSide(JSplitPane splitPane, Component focus) {
Component left = splitPane.getLeftComponent();
Component right = splitPane.getRightComponent();
Component next;
if (focus!=null && SwingUtilities.isDescendingFrom(focus, left) &&
right!=null) {
next = getFirstAvailableComponent(right);
if (next != null) {
return next;
}
}
JSplitPane parentSplitPane = (JSplitPane)SwingUtilities.getAncestorOfClass(JSplitPane.class, splitPane);
if (parentSplitPane!=null) {
// focus next side of the parent split pane
next = getNextSide(parentSplitPane, focus);
} else {
next = getFirstAvailableComponent(left);
if (next == null) {
next = getFirstAvailableComponent(right);
}
}
return next;
}
private Component getFirstAvailableComponent(Component c) {
if (c!=null && c instanceof JSplitPane) {
JSplitPane sp = (JSplitPane)c;
Component left = getFirstAvailableComponent(sp.getLeftComponent());
if (left != null) {
c = left;
} else {
c = getFirstAvailableComponent(sp.getRightComponent());
}
}
return c;
}
}
}