basicsplitpaneui.java

JAVA 所有包

                                          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.
     * <p>
     */
    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) {