This class should be treated as a "protected" inner class. Instantiate it only within subclasses of BasicSplitPaneUI. 

This class should be treated as a "protected" inner class. Instantiate it only within subclasses of BasicSplitPaneUI. 

This class should be treated as a "protected" inner class. Instantiate it only within subclasses of BasicSplitPaneUI. 

This class should be treated as a "protected" inner class. Instantiate it only within subclasses of BasicSplitPaneUI. 

This class should be treated as a "protected" inner class. Instantiate it only within subclasses of BasicSplitPaneUI. 

This class should be treated as a "protected" inner class. Instantiate it only within subclasses of BasicSplitPaneUI. 

This class should be treated as a "protected" inner class. Instantiate it only within subclasses of BasicSplitPaneUI. 

 public BasicSplitPaneDivider createDefaultDivider() 
{
        return new BasicSplitPaneDivider(this);
}

Creates the default divider.

 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);
                    }
                }
            }
        };
}

Returns the default non continuous layout divider, which is an instanceof Canvas that fills the background in dark gray.

 protected FocusListener createFocusListener() 
{
        return getHandler();
}

Creates a FocusListener for the JSplitPane UI.

 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 installKeyboardActions and placing the Action in the SplitPane's ActionMap. Please refer to the key bindings specification for further details.

Creates a ActionListener for the JSplitPane UI that listens for specific key presses.

 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 installKeyboardActions and placing the Action in the SplitPane's ActionMap. Please refer to the key bindings specification for further details.

Creates a ActionListener for the JSplitPane UI that listens for specific key presses.

 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 installKeyboardActions and placing the Action in the SplitPane's ActionMap. Please refer to the key bindings specification for further details.

Creates a ActionListener for the JSplitPane UI that listens for specific key presses.

 protected ActionListener createKeyboardResizeToggleListener() 
{
        return new KeyboardResizeToggleHandler();
}

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 installKeyboardActions and placing the Action in the SplitPane's ActionMap. Please refer to the key bindings specification for further details.

Creates a ActionListener for the JSplitPane UI that listens for specific key presses.

 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 installKeyboardActions and placing the Action in the SplitPane's ActionMap. Please refer to the key bindings specification for further details.

Creates a ActionListener for the JSplitPane UI that listens for specific key presses.

 protected PropertyChangeListener createPropertyChangeListener() 
{
        return getHandler();
}

Creates a PropertyChangeListener for the JSplitPane UI.

 public static ComponentUI createUI(JComponent x) 
{
              
        return new BasicSplitPaneUI();
}

Creates a new BasicSplitPaneUI instance

 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 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 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);
        }
}

Messaged to finish the dragging session. If not continuous display the dividers location will be reset.

 public  void finishedPaintingChildren(JSplitPane jc,
    Graphics g) 
{
        if(jc == 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);
            }
        }
}

Messaged after the JSplitPane the receiver is providing the look and feel for paints its children.

 public BasicSplitPaneDivider getDivider() 
{
        return divider;
}

Returns the divider between the top Components.

 protected int getDividerBorderSize() 
{
        return 1;
}

As of Java 2 platform v1.3 this method is no longer used. Instead you should set the border on the divider.

Returns the width of one side of the divider border.

 public int getDividerLocation(JSplitPane jc) 
{
        if(orientation == JSplitPane.HORIZONTAL_SPLIT)
            return divider.getLocation().x;
        return divider.getLocation().y;
}

Returns the location of the divider, which may differ from what the splitpane thinks the location of the divider is.

 InputMap getInputMap(int condition) 
{
        if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT) {
            return (InputMap)DefaultLookup.get(splitPane, this,
                                               "SplitPane.ancestorInputMap");
        }
        return null;
}

 public Insets getInsets(JComponent jc) 
{
        return null;
}

Returns the insets. The insets are returned from the border insets of the current border.

 int getKeyboardMoveIncrement() 
{
        return KEYBOARD_DIVIDER_MOVE_OFFSET;
}

 public int getLastDragLocation() 
{
        return lastDragLocation;
}

Returns the last drag location of the JSplitPane.

 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);
}

Gets the maximum location of the divider.

 public Dimension getMaximumSize(JComponent jc) 
{
        if(splitPane != null)
            return layoutManager.maximumLayoutSize(splitPane);
        return new Dimension(0, 0);
}

Returns the maximum size for the passed in component, This is passed off to the current layoutmanager.

 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 minimum location of the divider.

 public Dimension getMinimumSize(JComponent jc) 
{
        if(splitPane != null)
            return layoutManager.minimumLayoutSize(splitPane);
        return new Dimension(0, 0);
}

Returns the minimum size for the passed in component, This is passed off to the current layoutmanager.

 public Component getNonContinuousLayoutDivider() 
{
        return nonContinuousLayoutDivider;
}

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 int getOrientation() 
{
        return orientation;
}

Returns the orientation for the JSplitPane.

 public Dimension getPreferredSize(JComponent jc) 
{
        if(splitPane != null)
            return layoutManager.preferredLayoutSize(splitPane);
        return new Dimension(0, 0);
}

Returns the preferred size for the passed in component, This is passed off to the current layoutmanager.

 public JSplitPane getSplitPane() 
{
        return splitPane;
}

Returns the splitpane this instance is currently contained in.

 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());
        // This plus 2 here is to provide backwards consistancy. Previously,
        // the old size did not include the 2 pixel border around the divider,
        // it now does.
        LookAndFeel.installProperty(splitPane, "dividerSize",
                                    UIManager.get("SplitPane.dividerSize"));
        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();
            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();
            managingFocusBackwardTraversalKeys.add(
                KeyStroke.getKeyStroke(KeyEvent.VK_TAB, InputEvent.SHIFT_MASK));
        }
        splitPane.setFocusTraversalKeys(KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS,
                                        managingFocusBackwardTraversalKeys);
}

Installs the UI defaults.

 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");
}

Installs the keyboard actions for the UI.

 protected  void installListeners() 
{
        if ((propertyChangeListener = createPropertyChangeListener()) !=
            null) {
            splitPane.addPropertyChangeListener(propertyChangeListener);
        }
        if ((focusListener = createFocusListener()) != null) {
            splitPane.addFocusListener(focusListener);
        }
}

Installs the event listeners for the UI.

 public  void installUI(JComponent c) 
{
        splitPane = (JSplitPane) c;
        dividerLocationIsSet = false;
        dividerKeyboardResize = false;
        keepHidden = false;
        installDefaults();
        installListeners();
        installKeyboardActions();
        setLastDragLocation(-1);
}

Installs the UI.

 public boolean isContinuousLayout() 
{
        return continuousLayout;
}

Determines wether the JSplitPane is set to use a continuous layout.

 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));
}

 public  void paint(Graphics g,
    JComponent jc) 
{
        if (!painted && splitPane.getDividerLocation()< 0) {
            ignoreDividerLocationChange = true;
            splitPane.setDividerLocation(getDividerLocation(splitPane));
        }
        painted = true;
}

Messaged to paint the look and feel.

 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();
}

Resets the layout manager based on orientation and messages it with invalidateLayout to pull in appropriate Components.

 public  void resetToPreferredSizes(JSplitPane jc) 
{
        if(splitPane != null) {
            layoutManager.resetToPreferredSizes();
            splitPane.revalidate();
            splitPane.repaint();
        }
}

Messaged to reset the preferred sizes.

 public  void setContinuousLayout(boolean b) 
{
        continuousLayout = b;
}

Turn continuous layout on/off.

 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;
        }
}

Sets the location of the divider to location.

  void setKeepHidden(boolean keepHidden) 
{
        this.keepHidden = keepHidden;
}

Set the value to indicate if one of the splitpane sides is expanded.

 public  void setLastDragLocation(int l) 
{
        lastDragLocation = l;
}

Set the last drag location of the JSplitPane.

 protected  void setNonContinuousLayoutDivider(Component newDivider) 
{
        setNonContinuousLayoutDivider(newDivider, true);
}

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,
    boolean rememberSizes) 
{
        rememberPaneSizes = rememberSizes;
        if(nonContinuousLayoutDivider != null && splitPane != null) {
            splitPane.remove(nonContinuousLayoutDivider);
        }
        nonContinuousLayoutDivider = newDivider;
}

Sets the divider to use.

 public  void setOrientation(int orientation) 
{
        this.orientation = orientation;
}

Set the orientation for the JSplitPane.

 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();
            }
        }
}

Should be messaged before the dragging session starts, resets lastDragLocation and dividerSize.

 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 UI defaults.

 protected  void uninstallKeyboardActions() 
{
        SwingUtilities.replaceUIActionMap(splitPane, null);
        SwingUtilities.replaceUIInputMap(splitPane, JComponent.
                                      WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,
                                      null);
}

Uninstalls the keyboard actions 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 event listeners for the UI.

 public  void uninstallUI(JComponent c) 
{
        uninstallKeyboardActions();
        uninstallListeners();
        uninstallDefaults();
        dividerLocationIsSet = false;
        dividerKeyboardResize = false;
        splitPane = null;
}

Uninstalls the UI.