| /* |
| * 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 java.awt.*; |
| import java.awt.event.*; |
| import javax.swing.*; |
| import javax.swing.event.*; |
| import javax.swing.plaf.*; |
| import javax.swing.border.Border; |
| import java.beans.*; |
| import sun.swing.DefaultLookup; |
| |
| |
| |
| /** |
| * Divider used by BasicSplitPaneUI. Subclassers may wish to override |
| * paint to do something more interesting. |
| * The border effect is drawn in BasicSplitPaneUI, so if you don't like |
| * that border, reset it there. |
| * To conditionally drag from certain areas subclass mousePressed and |
| * call super when you wish the dragging to begin. |
| * <p> |
| * <strong>Warning:</strong> |
| * Serialized objects of this class will not be compatible with |
| * future Swing releases. The current serialization support is |
| * appropriate for short term storage or RMI between applications running |
| * the same version of Swing. As of 1.4, support for long term storage |
| * of all JavaBeans™ |
| * has been added to the <code>java.beans</code> package. |
| * Please see {@link java.beans.XMLEncoder}. |
| * |
| * @author Scott Violet |
| */ |
| @SuppressWarnings("serial") // Same-version serialization only |
| public class BasicSplitPaneDivider extends Container |
| implements PropertyChangeListener |
| { |
| /** |
| * Width or height of the divider based on orientation |
| * {@code BasicSplitPaneUI} adds two to this. |
| */ |
| protected static final int ONE_TOUCH_SIZE = 6; |
| |
| /** |
| * The offset of the divider. |
| */ |
| protected static final int ONE_TOUCH_OFFSET = 2; |
| |
| /** |
| * Handles mouse dragging message to do the actual dragging. |
| */ |
| protected DragController dragger; |
| |
| /** |
| * UI this instance was created from. |
| */ |
| protected BasicSplitPaneUI splitPaneUI; |
| |
| /** |
| * Size of the divider. |
| */ |
| protected int dividerSize = 0; // default - SET TO 0??? |
| |
| /** |
| * Divider that is used for noncontinuous layout mode. |
| */ |
| protected Component hiddenDivider; |
| |
| /** |
| * JSplitPane the receiver is contained in. |
| */ |
| protected JSplitPane splitPane; |
| |
| /** |
| * Handles mouse events from both this class, and the split pane. |
| * Mouse events are handled for the splitpane since you want to be able |
| * to drag when clicking on the border of the divider, which is not |
| * drawn by the divider. |
| */ |
| protected MouseHandler mouseHandler; |
| |
| /** |
| * Orientation of the JSplitPane. |
| */ |
| protected int orientation; |
| |
| /** |
| * Button for quickly toggling the left component. |
| */ |
| protected JButton leftButton; |
| |
| /** |
| * Button for quickly toggling the right component. |
| */ |
| protected JButton rightButton; |
| |
| /** Border. */ |
| private Border border; |
| |
| /** |
| * Is the mouse over the divider? |
| */ |
| private boolean mouseOver; |
| |
| private int oneTouchSize; |
| private int oneTouchOffset; |
| |
| /** |
| * If true the one touch buttons are centered on the divider. |
| */ |
| private boolean centerOneTouchButtons; |
| |
| |
| /** |
| * Creates an instance of {@code BasicSplitPaneDivider}. Registers this |
| * instance for mouse events and mouse dragged events. |
| * |
| * @param ui an instance of {@code BasicSplitPaneUI} |
| */ |
| public BasicSplitPaneDivider(BasicSplitPaneUI ui) { |
| oneTouchSize = DefaultLookup.getInt(ui.getSplitPane(), ui, |
| "SplitPane.oneTouchButtonSize", ONE_TOUCH_SIZE); |
| oneTouchOffset = DefaultLookup.getInt(ui.getSplitPane(), ui, |
| "SplitPane.oneTouchButtonOffset", ONE_TOUCH_OFFSET); |
| centerOneTouchButtons = DefaultLookup.getBoolean(ui.getSplitPane(), |
| ui, "SplitPane.centerOneTouchButtons", true); |
| setLayout(new DividerLayout()); |
| setBasicSplitPaneUI(ui); |
| orientation = splitPane.getOrientation(); |
| setCursor((orientation == JSplitPane.HORIZONTAL_SPLIT) ? |
| Cursor.getPredefinedCursor(Cursor.E_RESIZE_CURSOR) : |
| Cursor.getPredefinedCursor(Cursor.S_RESIZE_CURSOR)); |
| setBackground(UIManager.getColor("SplitPane.background")); |
| } |
| |
| private void revalidateSplitPane() { |
| invalidate(); |
| if (splitPane != null) { |
| splitPane.revalidate(); |
| } |
| } |
| |
| /** |
| * Sets the {@code SplitPaneUI} that is using the receiver. |
| * |
| * @param newUI the new {@code SplitPaneUI} |
| */ |
| public void setBasicSplitPaneUI(BasicSplitPaneUI newUI) { |
| if (splitPane != null) { |
| splitPane.removePropertyChangeListener(this); |
| if (mouseHandler != null) { |
| splitPane.removeMouseListener(mouseHandler); |
| splitPane.removeMouseMotionListener(mouseHandler); |
| removeMouseListener(mouseHandler); |
| removeMouseMotionListener(mouseHandler); |
| mouseHandler = null; |
| } |
| } |
| splitPaneUI = newUI; |
| if (newUI != null) { |
| splitPane = newUI.getSplitPane(); |
| if (splitPane != null) { |
| if (mouseHandler == null) mouseHandler = new MouseHandler(); |
| splitPane.addMouseListener(mouseHandler); |
| splitPane.addMouseMotionListener(mouseHandler); |
| addMouseListener(mouseHandler); |
| addMouseMotionListener(mouseHandler); |
| splitPane.addPropertyChangeListener(this); |
| if (splitPane.isOneTouchExpandable()) { |
| oneTouchExpandableChanged(); |
| } |
| } |
| } |
| else { |
| splitPane = null; |
| } |
| } |
| |
| |
| /** |
| * Returns the {@code SplitPaneUI} the receiver is currently in. |
| * |
| * @return the {@code SplitPaneUI} the receiver is currently in |
| */ |
| public BasicSplitPaneUI getBasicSplitPaneUI() { |
| return splitPaneUI; |
| } |
| |
| |
| /** |
| * Sets the size of the divider to {@code newSize}. That is |
| * the width if the splitpane is {@code HORIZONTAL_SPLIT}, or |
| * the height of {@code VERTICAL_SPLIT}. |
| * |
| * @param newSize a new size |
| */ |
| public void setDividerSize(int newSize) { |
| dividerSize = newSize; |
| } |
| |
| |
| /** |
| * Returns the size of the divider, that is the width if the splitpane |
| * is HORIZONTAL_SPLIT, or the height of VERTICAL_SPLIT. |
| * |
| * @return the size of the divider |
| */ |
| public int getDividerSize() { |
| return dividerSize; |
| } |
| |
| |
| /** |
| * Sets the border of this component. |
| * |
| * @param border a new border |
| * @since 1.3 |
| */ |
| public void setBorder(Border border) { |
| Border oldBorder = this.border; |
| |
| this.border = border; |
| } |
| |
| /** |
| * Returns the border of this component or null if no border is |
| * currently set. |
| * |
| * @return the border object for this component |
| * @see #setBorder |
| * @since 1.3 |
| */ |
| public Border getBorder() { |
| return border; |
| } |
| |
| /** |
| * If a border has been set on this component, returns the |
| * border's insets, else calls super.getInsets. |
| * |
| * @return the value of the insets property. |
| * @see #setBorder |
| */ |
| public Insets getInsets() { |
| Border border = getBorder(); |
| |
| if (border != null) { |
| return border.getBorderInsets(this); |
| } |
| return super.getInsets(); |
| } |
| |
| /** |
| * Sets whether or not the mouse is currently over the divider. |
| * |
| * @param mouseOver whether or not the mouse is currently over the divider |
| * @since 1.5 |
| */ |
| protected void setMouseOver(boolean mouseOver) { |
| this.mouseOver = mouseOver; |
| } |
| |
| /** |
| * Returns whether or not the mouse is currently over the divider |
| * |
| * @return whether or not the mouse is currently over the divider |
| * @since 1.5 |
| */ |
| public boolean isMouseOver() { |
| return mouseOver; |
| } |
| |
| /** |
| * Returns dividerSize x dividerSize |
| */ |
| public Dimension getPreferredSize() { |
| // Ideally this would return the size from the layout manager, |
| // but that could result in the layed out size being different from |
| // the dividerSize, which may break developers as well as |
| // BasicSplitPaneUI. |
| if (orientation == JSplitPane.HORIZONTAL_SPLIT) { |
| return new Dimension(getDividerSize(), 1); |
| } |
| return new Dimension(1, getDividerSize()); |
| } |
| |
| /** |
| * Returns dividerSize x dividerSize |
| */ |
| public Dimension getMinimumSize() { |
| return getPreferredSize(); |
| } |
| |
| |
| /** |
| * Property change event, presumably from the JSplitPane, will message |
| * updateOrientation if necessary. |
| */ |
| public void propertyChange(PropertyChangeEvent e) { |
| if (e.getSource() == splitPane) { |
| if (e.getPropertyName() == JSplitPane.ORIENTATION_PROPERTY) { |
| orientation = splitPane.getOrientation(); |
| setCursor((orientation == JSplitPane.HORIZONTAL_SPLIT) ? |
| Cursor.getPredefinedCursor(Cursor.E_RESIZE_CURSOR) : |
| Cursor.getPredefinedCursor(Cursor.S_RESIZE_CURSOR)); |
| revalidateSplitPane(); |
| } |
| else if (e.getPropertyName() == JSplitPane. |
| ONE_TOUCH_EXPANDABLE_PROPERTY) { |
| oneTouchExpandableChanged(); |
| } |
| } |
| } |
| |
| |
| /** |
| * Paints the divider. |
| */ |
| public void paint(Graphics g) { |
| super.paint(g); |
| |
| // Paint the border. |
| Border border = getBorder(); |
| |
| if (border != null) { |
| Dimension size = getSize(); |
| |
| border.paintBorder(this, g, 0, 0, size.width, size.height); |
| } |
| } |
| |
| |
| /** |
| * Messaged when the oneTouchExpandable value of the JSplitPane the |
| * receiver is contained in changes. Will create the |
| * <code>leftButton</code> and <code>rightButton</code> if they |
| * are null. invalidates the receiver as well. |
| */ |
| protected void oneTouchExpandableChanged() { |
| if (!DefaultLookup.getBoolean(splitPane, splitPaneUI, |
| "SplitPane.supportsOneTouchButtons", true)) { |
| // Look and feel doesn't want to support one touch buttons, bail. |
| return; |
| } |
| if (splitPane.isOneTouchExpandable() && |
| leftButton == null && |
| rightButton == null) { |
| /* Create the left button and add an action listener to |
| expand/collapse it. */ |
| leftButton = createLeftOneTouchButton(); |
| if (leftButton != null) |
| leftButton.addActionListener(new OneTouchActionHandler(true)); |
| |
| |
| /* Create the right button and add an action listener to |
| expand/collapse it. */ |
| rightButton = createRightOneTouchButton(); |
| if (rightButton != null) |
| rightButton.addActionListener(new OneTouchActionHandler |
| (false)); |
| |
| if (leftButton != null && rightButton != null) { |
| add(leftButton); |
| add(rightButton); |
| } |
| } |
| revalidateSplitPane(); |
| } |
| |
| |
| /** |
| * Creates and return an instance of {@code JButton} that can be used to |
| * collapse the left component in the split pane. |
| * |
| * @return an instance of {@code JButton} |
| */ |
| protected JButton createLeftOneTouchButton() { |
| JButton b = new JButton() { |
| public void setBorder(Border b) { |
| } |
| public void paint(Graphics g) { |
| if (splitPane != null) { |
| int[] xs = new int[3]; |
| int[] ys = new int[3]; |
| int blockSize; |
| |
| // Fill the background first ... |
| g.setColor(this.getBackground()); |
| g.fillRect(0, 0, this.getWidth(), |
| this.getHeight()); |
| |
| // ... then draw the arrow. |
| g.setColor(Color.black); |
| if (orientation == JSplitPane.VERTICAL_SPLIT) { |
| blockSize = Math.min(getHeight(), oneTouchSize); |
| xs[0] = blockSize; |
| xs[1] = 0; |
| xs[2] = blockSize << 1; |
| ys[0] = 0; |
| ys[1] = ys[2] = blockSize; |
| g.drawPolygon(xs, ys, 3); // Little trick to make the |
| // arrows of equal size |
| } |
| else { |
| blockSize = Math.min(getWidth(), oneTouchSize); |
| xs[0] = xs[2] = blockSize; |
| xs[1] = 0; |
| ys[0] = 0; |
| ys[1] = blockSize; |
| ys[2] = blockSize << 1; |
| } |
| g.fillPolygon(xs, ys, 3); |
| } |
| } |
| // Don't want the button to participate in focus traversable. |
| @SuppressWarnings("deprecation") |
| public boolean isFocusTraversable() { |
| return false; |
| } |
| }; |
| b.setMinimumSize(new Dimension(oneTouchSize, oneTouchSize)); |
| b.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR)); |
| b.setFocusPainted(false); |
| b.setBorderPainted(false); |
| b.setRequestFocusEnabled(false); |
| return b; |
| } |
| |
| |
| /** |
| * Creates and return an instance of {@code JButton} that can be used to |
| * collapse the right component in the split pane. |
| * |
| * @return an instance of {@code JButton} |
| */ |
| protected JButton createRightOneTouchButton() { |
| JButton b = new JButton() { |
| public void setBorder(Border border) { |
| } |
| public void paint(Graphics g) { |
| if (splitPane != null) { |
| int[] xs = new int[3]; |
| int[] ys = new int[3]; |
| int blockSize; |
| |
| // Fill the background first ... |
| g.setColor(this.getBackground()); |
| g.fillRect(0, 0, this.getWidth(), |
| this.getHeight()); |
| |
| // ... then draw the arrow. |
| if (orientation == JSplitPane.VERTICAL_SPLIT) { |
| blockSize = Math.min(getHeight(), oneTouchSize); |
| xs[0] = blockSize; |
| xs[1] = blockSize << 1; |
| xs[2] = 0; |
| ys[0] = blockSize; |
| ys[1] = ys[2] = 0; |
| } |
| else { |
| blockSize = Math.min(getWidth(), oneTouchSize); |
| xs[0] = xs[2] = 0; |
| xs[1] = blockSize; |
| ys[0] = 0; |
| ys[1] = blockSize; |
| ys[2] = blockSize << 1; |
| } |
| g.setColor(Color.black); |
| g.fillPolygon(xs, ys, 3); |
| } |
| } |
| // Don't want the button to participate in focus traversable. |
| @SuppressWarnings("deprecation") |
| public boolean isFocusTraversable() { |
| return false; |
| } |
| }; |
| b.setMinimumSize(new Dimension(oneTouchSize, oneTouchSize)); |
| b.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR)); |
| b.setFocusPainted(false); |
| b.setBorderPainted(false); |
| b.setRequestFocusEnabled(false); |
| return b; |
| } |
| |
| |
| /** |
| * Message to prepare for dragging. This messages the BasicSplitPaneUI |
| * with startDragging. |
| */ |
| protected void prepareForDragging() { |
| splitPaneUI.startDragging(); |
| } |
| |
| |
| /** |
| * Messages the BasicSplitPaneUI with dragDividerTo that this instance |
| * is contained in. |
| * |
| * @param location a location |
| */ |
| protected void dragDividerTo(int location) { |
| splitPaneUI.dragDividerTo(location); |
| } |
| |
| |
| /** |
| * Messages the BasicSplitPaneUI with finishDraggingTo that this instance |
| * is contained in. |
| * |
| * @param location a location |
| */ |
| protected void finishDraggingTo(int location) { |
| splitPaneUI.finishDraggingTo(location); |
| } |
| |
| |
| /** |
| * MouseHandler is responsible for converting mouse events |
| * (released, dragged...) into the appropriate DragController |
| * methods. |
| * |
| */ |
| protected class MouseHandler extends MouseAdapter |
| implements MouseMotionListener |
| { |
| /** |
| * Starts the dragging session by creating the appropriate instance |
| * of DragController. |
| */ |
| public void mousePressed(MouseEvent e) { |
| if ((e.getSource() == BasicSplitPaneDivider.this || |
| e.getSource() == splitPane) && |
| dragger == null &&splitPane.isEnabled()) { |
| Component newHiddenDivider = splitPaneUI. |
| getNonContinuousLayoutDivider(); |
| |
| if (hiddenDivider != newHiddenDivider) { |
| if (hiddenDivider != null) { |
| hiddenDivider.removeMouseListener(this); |
| hiddenDivider.removeMouseMotionListener(this); |
| } |
| hiddenDivider = newHiddenDivider; |
| if (hiddenDivider != null) { |
| hiddenDivider.addMouseMotionListener(this); |
| hiddenDivider.addMouseListener(this); |
| } |
| } |
| if (splitPane.getLeftComponent() != null && |
| splitPane.getRightComponent() != null) { |
| if (orientation == JSplitPane.HORIZONTAL_SPLIT) { |
| dragger = new DragController(e); |
| } |
| else { |
| dragger = new VerticalDragController(e); |
| } |
| if (!dragger.isValid()) { |
| dragger = null; |
| } |
| else { |
| prepareForDragging(); |
| dragger.continueDrag(e); |
| } |
| } |
| e.consume(); |
| } |
| } |
| |
| |
| /** |
| * If dragger is not null it is messaged with completeDrag. |
| */ |
| public void mouseReleased(MouseEvent e) { |
| if (dragger != null) { |
| if (e.getSource() == splitPane) { |
| dragger.completeDrag(e.getX(), e.getY()); |
| } |
| else if (e.getSource() == BasicSplitPaneDivider.this) { |
| Point ourLoc = getLocation(); |
| |
| dragger.completeDrag(e.getX() + ourLoc.x, |
| e.getY() + ourLoc.y); |
| } |
| else if (e.getSource() == hiddenDivider) { |
| Point hDividerLoc = hiddenDivider.getLocation(); |
| int ourX = e.getX() + hDividerLoc.x; |
| int ourY = e.getY() + hDividerLoc.y; |
| |
| dragger.completeDrag(ourX, ourY); |
| } |
| dragger = null; |
| e.consume(); |
| } |
| } |
| |
| |
| // |
| // MouseMotionListener |
| // |
| |
| /** |
| * If dragger is not null it is messaged with continueDrag. |
| */ |
| public void mouseDragged(MouseEvent e) { |
| if (dragger != null) { |
| if (e.getSource() == splitPane) { |
| dragger.continueDrag(e.getX(), e.getY()); |
| } |
| else if (e.getSource() == BasicSplitPaneDivider.this) { |
| Point ourLoc = getLocation(); |
| |
| dragger.continueDrag(e.getX() + ourLoc.x, |
| e.getY() + ourLoc.y); |
| } |
| else if (e.getSource() == hiddenDivider) { |
| Point hDividerLoc = hiddenDivider.getLocation(); |
| int ourX = e.getX() + hDividerLoc.x; |
| int ourY = e.getY() + hDividerLoc.y; |
| |
| dragger.continueDrag(ourX, ourY); |
| } |
| e.consume(); |
| } |
| } |
| |
| |
| /** |
| * Resets the cursor based on the orientation. |
| */ |
| public void mouseMoved(MouseEvent e) { |
| } |
| |
| /** |
| * Invoked when the mouse enters a component. |
| * |
| * @param e MouseEvent describing the details of the enter event. |
| * @since 1.5 |
| */ |
| public void mouseEntered(MouseEvent e) { |
| if (e.getSource() == BasicSplitPaneDivider.this) { |
| setMouseOver(true); |
| } |
| } |
| |
| /** |
| * Invoked when the mouse exits a component. |
| * |
| * @param e MouseEvent describing the details of the exit event. |
| * @since 1.5 |
| */ |
| public void mouseExited(MouseEvent e) { |
| if (e.getSource() == BasicSplitPaneDivider.this) { |
| setMouseOver(false); |
| } |
| } |
| } |
| |
| |
| /** |
| * Handles the events during a dragging session for a |
| * HORIZONTAL_SPLIT oriented split pane. This continually |
| * messages <code>dragDividerTo</code> and then when done messages |
| * <code>finishDraggingTo</code>. When an instance is created it should be |
| * messaged with <code>isValid</code> to insure that dragging can happen |
| * (dragging won't be allowed if the two views can not be resized). |
| * <p> |
| * <strong>Warning:</strong> |
| * Serialized objects of this class will not be compatible with |
| * future Swing releases. The current serialization support is |
| * appropriate for short term storage or RMI between applications running |
| * the same version of Swing. As of 1.4, support for long term storage |
| * of all JavaBeans™ |
| * has been added to the <code>java.beans</code> package. |
| * Please see {@link java.beans.XMLEncoder}. |
| */ |
| @SuppressWarnings("serial") // Same-version serialization only |
| protected class DragController |
| { |
| /** |
| * Initial location of the divider. |
| */ |
| int initialX; |
| |
| /** |
| * Maximum and minimum positions to drag to. |
| */ |
| int maxX, minX; |
| |
| /** |
| * Initial location the mouse down happened at. |
| */ |
| int offset; |
| |
| /** |
| * Constructs a new instance of {@code DragController}. |
| * |
| * @param e a mouse event |
| */ |
| protected DragController(MouseEvent e) { |
| JSplitPane splitPane = splitPaneUI.getSplitPane(); |
| Component leftC = splitPane.getLeftComponent(); |
| Component rightC = splitPane.getRightComponent(); |
| |
| initialX = getLocation().x; |
| if (e.getSource() == BasicSplitPaneDivider.this) { |
| offset = e.getX(); |
| } |
| else { // splitPane |
| offset = e.getX() - initialX; |
| } |
| if (leftC == null || rightC == null || offset < -1 || |
| offset >= getSize().width) { |
| // Don't allow dragging. |
| maxX = -1; |
| } |
| else { |
| Insets insets = splitPane.getInsets(); |
| |
| if (leftC.isVisible()) { |
| minX = leftC.getMinimumSize().width; |
| if (insets != null) { |
| minX += insets.left; |
| } |
| } |
| else { |
| minX = 0; |
| } |
| if (rightC.isVisible()) { |
| int right = (insets != null) ? insets.right : 0; |
| maxX = Math.max(0, splitPane.getSize().width - |
| (getSize().width + right) - |
| rightC.getMinimumSize().width); |
| } |
| else { |
| int right = (insets != null) ? insets.right : 0; |
| maxX = Math.max(0, splitPane.getSize().width - |
| (getSize().width + right)); |
| } |
| if (maxX < minX) minX = maxX = 0; |
| } |
| } |
| |
| |
| /** |
| * Returns {@code true} if the dragging session is valid. |
| * |
| * @return {@code true} if the dragging session is valid |
| */ |
| protected boolean isValid() { |
| return (maxX > 0); |
| } |
| |
| |
| /** |
| * Returns the new position to put the divider at based on |
| * the passed in MouseEvent. |
| * |
| * @param e a mouse event |
| * @return the new position |
| */ |
| protected int positionForMouseEvent(MouseEvent e) { |
| int newX = (e.getSource() == BasicSplitPaneDivider.this) ? |
| (e.getX() + getLocation().x) : e.getX(); |
| |
| newX = Math.min(maxX, Math.max(minX, newX - offset)); |
| return newX; |
| } |
| |
| |
| /** |
| * Returns the x argument, since this is used for horizontal |
| * splits. |
| * |
| * @param x an X coordinate |
| * @param y an Y coordinate |
| * @return the X argument |
| */ |
| protected int getNeededLocation(int x, int y) { |
| int newX; |
| |
| newX = Math.min(maxX, Math.max(minX, x - offset)); |
| return newX; |
| } |
| |
| /** |
| * Messages dragDividerTo with the new location for the mouse |
| * event. |
| * |
| * @param newX an X coordinate |
| * @param newY an Y coordinate |
| */ |
| protected void continueDrag(int newX, int newY) { |
| dragDividerTo(getNeededLocation(newX, newY)); |
| } |
| |
| |
| /** |
| * Messages dragDividerTo with the new location for the mouse |
| * event. |
| * |
| * @param e a mouse event |
| */ |
| protected void continueDrag(MouseEvent e) { |
| dragDividerTo(positionForMouseEvent(e)); |
| } |
| |
| /** |
| * Messages finishDraggingTo with the new location for the mouse |
| * event. |
| * |
| * @param x an X coordinate |
| * @param y an Y coordinate |
| */ |
| protected void completeDrag(int x, int y) { |
| finishDraggingTo(getNeededLocation(x, y)); |
| } |
| |
| |
| /** |
| * Messages finishDraggingTo with the new location for the mouse |
| * event. |
| * |
| * @param e a mouse event |
| */ |
| protected void completeDrag(MouseEvent e) { |
| finishDraggingTo(positionForMouseEvent(e)); |
| } |
| } // End of BasicSplitPaneDivider.DragController |
| |
| |
| /** |
| * Handles the events during a dragging session for a |
| * VERTICAL_SPLIT oriented split pane. This continually |
| * messages <code>dragDividerTo</code> and then when done messages |
| * <code>finishDraggingTo</code>. When an instance is created it should be |
| * messaged with <code>isValid</code> to insure that dragging can happen |
| * (dragging won't be allowed if the two views can not be resized). |
| */ |
| protected class VerticalDragController extends DragController |
| { |
| /* DragControllers ivars are now in terms of y, not x. */ |
| /** |
| * Constructs a new instance of {@code VerticalDragController}. |
| * |
| * @param e a mouse event |
| */ |
| protected VerticalDragController(MouseEvent e) { |
| super(e); |
| JSplitPane splitPane = splitPaneUI.getSplitPane(); |
| Component leftC = splitPane.getLeftComponent(); |
| Component rightC = splitPane.getRightComponent(); |
| |
| initialX = getLocation().y; |
| if (e.getSource() == BasicSplitPaneDivider.this) { |
| offset = e.getY(); |
| } |
| else { |
| offset = e.getY() - initialX; |
| } |
| if (leftC == null || rightC == null || offset < -1 || |
| offset > getSize().height) { |
| // Don't allow dragging. |
| maxX = -1; |
| } |
| else { |
| Insets insets = splitPane.getInsets(); |
| |
| if (leftC.isVisible()) { |
| minX = leftC.getMinimumSize().height; |
| if (insets != null) { |
| minX += insets.top; |
| } |
| } |
| else { |
| minX = 0; |
| } |
| if (rightC.isVisible()) { |
| int bottom = (insets != null) ? insets.bottom : 0; |
| |
| maxX = Math.max(0, splitPane.getSize().height - |
| (getSize().height + bottom) - |
| rightC.getMinimumSize().height); |
| } |
| else { |
| int bottom = (insets != null) ? insets.bottom : 0; |
| |
| maxX = Math.max(0, splitPane.getSize().height - |
| (getSize().height + bottom)); |
| } |
| if (maxX < minX) minX = maxX = 0; |
| } |
| } |
| |
| |
| /** |
| * Returns the y argument, since this is used for vertical |
| * splits. |
| */ |
| protected int getNeededLocation(int x, int y) { |
| int newY; |
| |
| newY = Math.min(maxX, Math.max(minX, y - offset)); |
| return newY; |
| } |
| |
| |
| /** |
| * Returns the new position to put the divider at based on |
| * the passed in MouseEvent. |
| */ |
| protected int positionForMouseEvent(MouseEvent e) { |
| int newY = (e.getSource() == BasicSplitPaneDivider.this) ? |
| (e.getY() + getLocation().y) : e.getY(); |
| |
| |
| newY = Math.min(maxX, Math.max(minX, newY - offset)); |
| return newY; |
| } |
| } // End of BasicSplitPaneDividier.VerticalDragController |
| |
| |
| /** |
| * Used to layout a <code>BasicSplitPaneDivider</code>. |
| * Layout for the divider |
| * involves appropriately moving the left/right buttons around. |
| * |
| */ |
| protected class DividerLayout implements LayoutManager |
| { |
| public void layoutContainer(Container c) { |
| if (leftButton != null && rightButton != null && |
| c == BasicSplitPaneDivider.this) { |
| if (splitPane.isOneTouchExpandable()) { |
| Insets insets = getInsets(); |
| |
| if (orientation == JSplitPane.VERTICAL_SPLIT) { |
| int extraX = (insets != null) ? insets.left : 0; |
| int blockSize = getHeight(); |
| |
| if (insets != null) { |
| blockSize -= (insets.top + insets.bottom); |
| blockSize = Math.max(blockSize, 0); |
| } |
| blockSize = Math.min(blockSize, oneTouchSize); |
| |
| int y = (c.getSize().height - blockSize) / 2; |
| |
| if (!centerOneTouchButtons) { |
| y = (insets != null) ? insets.top : 0; |
| extraX = 0; |
| } |
| leftButton.setBounds(extraX + oneTouchOffset, y, |
| blockSize * 2, blockSize); |
| rightButton.setBounds(extraX + oneTouchOffset + |
| oneTouchSize * 2, y, |
| blockSize * 2, blockSize); |
| } |
| else { |
| int extraY = (insets != null) ? insets.top : 0; |
| int blockSize = getWidth(); |
| |
| if (insets != null) { |
| blockSize -= (insets.left + insets.right); |
| blockSize = Math.max(blockSize, 0); |
| } |
| blockSize = Math.min(blockSize, oneTouchSize); |
| |
| int x = (c.getSize().width - blockSize) / 2; |
| |
| if (!centerOneTouchButtons) { |
| x = (insets != null) ? insets.left : 0; |
| extraY = 0; |
| } |
| |
| leftButton.setBounds(x, extraY + oneTouchOffset, |
| blockSize, blockSize * 2); |
| rightButton.setBounds(x, extraY + oneTouchOffset + |
| oneTouchSize * 2, blockSize, |
| blockSize * 2); |
| } |
| } |
| else { |
| leftButton.setBounds(-5, -5, 1, 1); |
| rightButton.setBounds(-5, -5, 1, 1); |
| } |
| } |
| } |
| |
| |
| public Dimension minimumLayoutSize(Container c) { |
| // NOTE: This isn't really used, refer to |
| // BasicSplitPaneDivider.getPreferredSize for the reason. |
| // I leave it in hopes of having this used at some point. |
| if (c != BasicSplitPaneDivider.this || splitPane == null) { |
| return new Dimension(0,0); |
| } |
| Dimension buttonMinSize = null; |
| |
| if (splitPane.isOneTouchExpandable() && leftButton != null) { |
| buttonMinSize = leftButton.getMinimumSize(); |
| } |
| |
| Insets insets = getInsets(); |
| int width = getDividerSize(); |
| int height = width; |
| |
| if (orientation == JSplitPane.VERTICAL_SPLIT) { |
| if (buttonMinSize != null) { |
| int size = buttonMinSize.height; |
| if (insets != null) { |
| size += insets.top + insets.bottom; |
| } |
| height = Math.max(height, size); |
| } |
| width = 1; |
| } |
| else { |
| if (buttonMinSize != null) { |
| int size = buttonMinSize.width; |
| if (insets != null) { |
| size += insets.left + insets.right; |
| } |
| width = Math.max(width, size); |
| } |
| height = 1; |
| } |
| return new Dimension(width, height); |
| } |
| |
| |
| public Dimension preferredLayoutSize(Container c) { |
| return minimumLayoutSize(c); |
| } |
| |
| |
| public void removeLayoutComponent(Component c) {} |
| |
| public void addLayoutComponent(String string, Component c) {} |
| } // End of class BasicSplitPaneDivider.DividerLayout |
| |
| |
| /** |
| * Listeners installed on the one touch expandable buttons. |
| */ |
| private class OneTouchActionHandler implements ActionListener { |
| /** True indicates the resize should go the minimum (top or left) |
| * vs false which indicates the resize should go to the maximum. |
| */ |
| private boolean toMinimum; |
| |
| OneTouchActionHandler(boolean toMinimum) { |
| this.toMinimum = toMinimum; |
| } |
| |
| public void actionPerformed(ActionEvent e) { |
| Insets insets = splitPane.getInsets(); |
| int lastLoc = splitPane.getLastDividerLocation(); |
| int currentLoc = splitPaneUI.getDividerLocation(splitPane); |
| int newLoc; |
| |
| // We use the location from the UI directly, as the location the |
| // JSplitPane itself maintains is not necessarly correct. |
| if (toMinimum) { |
| if (orientation == JSplitPane.VERTICAL_SPLIT) { |
| if (currentLoc >= (splitPane.getHeight() - |
| insets.bottom - getHeight())) { |
| int maxLoc = splitPane.getMaximumDividerLocation(); |
| newLoc = Math.min(lastLoc, maxLoc); |
| splitPaneUI.setKeepHidden(false); |
| } |
| else { |
| newLoc = insets.top; |
| splitPaneUI.setKeepHidden(true); |
| } |
| } |
| else { |
| if (currentLoc >= (splitPane.getWidth() - |
| insets.right - getWidth())) { |
| int maxLoc = splitPane.getMaximumDividerLocation(); |
| newLoc = Math.min(lastLoc, maxLoc); |
| splitPaneUI.setKeepHidden(false); |
| } |
| else { |
| newLoc = insets.left; |
| splitPaneUI.setKeepHidden(true); |
| } |
| } |
| } |
| else { |
| if (orientation == JSplitPane.VERTICAL_SPLIT) { |
| if (currentLoc == insets.top) { |
| int maxLoc = splitPane.getMaximumDividerLocation(); |
| newLoc = Math.min(lastLoc, maxLoc); |
| splitPaneUI.setKeepHidden(false); |
| } |
| else { |
| newLoc = splitPane.getHeight() - getHeight() - |
| insets.top; |
| splitPaneUI.setKeepHidden(true); |
| } |
| } |
| else { |
| if (currentLoc == insets.left) { |
| int maxLoc = splitPane.getMaximumDividerLocation(); |
| newLoc = Math.min(lastLoc, maxLoc); |
| splitPaneUI.setKeepHidden(false); |
| } |
| else { |
| newLoc = splitPane.getWidth() - getWidth() - |
| insets.left; |
| splitPaneUI.setKeepHidden(true); |
| } |
| } |
| } |
| if (currentLoc != newLoc) { |
| splitPane.setDividerLocation(newLoc); |
| // We do this in case the dividers notion of the location |
| // differs from the real location. |
| splitPane.setLastDividerLocation(currentLoc); |
| } |
| } |
| } // End of class BasicSplitPaneDivider.LeftActionListener |
| } |
