You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1623 lines
57 KiB
1623 lines
57 KiB
/*
|
|
* Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
package javax.swing.plaf.basic;
|
|
|
|
|
|
import sun.swing.DefaultLookup;
|
|
import sun.swing.UIAction;
|
|
|
|
import java.awt.*;
|
|
import java.awt.event.*;
|
|
|
|
import java.beans.*;
|
|
|
|
import javax.swing.*;
|
|
import javax.swing.event.*;
|
|
import javax.swing.plaf.*;
|
|
|
|
import static sun.swing.SwingUtilities2.drawHLine;
|
|
import static sun.swing.SwingUtilities2.drawRect;
|
|
import static sun.swing.SwingUtilities2.drawVLine;
|
|
|
|
|
|
/**
|
|
* Implementation of ScrollBarUI for the Basic Look and Feel
|
|
*
|
|
* @author Rich Schiavi
|
|
* @author David Kloba
|
|
* @author Hans Muller
|
|
*/
|
|
public class BasicScrollBarUI
|
|
extends ScrollBarUI implements LayoutManager, SwingConstants
|
|
{
|
|
private static final int POSITIVE_SCROLL = 1;
|
|
private static final int NEGATIVE_SCROLL = -1;
|
|
|
|
private static final int MIN_SCROLL = 2;
|
|
private static final int MAX_SCROLL = 3;
|
|
|
|
// NOTE: DO NOT use this field directly, SynthScrollBarUI assumes you'll
|
|
// call getMinimumThumbSize to access it.
|
|
protected Dimension minimumThumbSize;
|
|
protected Dimension maximumThumbSize;
|
|
|
|
protected Color thumbHighlightColor;
|
|
protected Color thumbLightShadowColor;
|
|
protected Color thumbDarkShadowColor;
|
|
protected Color thumbColor;
|
|
protected Color trackColor;
|
|
protected Color trackHighlightColor;
|
|
|
|
protected JScrollBar scrollbar;
|
|
protected JButton incrButton;
|
|
protected JButton decrButton;
|
|
protected boolean isDragging;
|
|
protected TrackListener trackListener;
|
|
protected ArrowButtonListener buttonListener;
|
|
protected ModelListener modelListener;
|
|
|
|
protected Rectangle thumbRect;
|
|
protected Rectangle trackRect;
|
|
|
|
protected int trackHighlight;
|
|
|
|
protected static final int NO_HIGHLIGHT = 0;
|
|
protected static final int DECREASE_HIGHLIGHT = 1;
|
|
protected static final int INCREASE_HIGHLIGHT = 2;
|
|
|
|
protected ScrollListener scrollListener;
|
|
protected PropertyChangeListener propertyChangeListener;
|
|
protected Timer scrollTimer;
|
|
|
|
private final static int scrollSpeedThrottle = 60; // delay in milli seconds
|
|
|
|
/** True indicates a middle click will absolutely position the
|
|
* scrollbar. */
|
|
private boolean supportsAbsolutePositioning;
|
|
|
|
/**
|
|
* Hint as to what width (when vertical) or height (when horizontal)
|
|
* should be.
|
|
*
|
|
* @since 1.7
|
|
*/
|
|
protected int scrollBarWidth;
|
|
|
|
private Handler handler;
|
|
|
|
private boolean thumbActive;
|
|
|
|
/**
|
|
* Determine whether scrollbar layout should use cached value or adjusted
|
|
* value returned by scrollbar's <code>getValue</code>.
|
|
*/
|
|
private boolean useCachedValue = false;
|
|
/**
|
|
* The scrollbar value is cached to save real value if the view is adjusted.
|
|
*/
|
|
private int scrollBarValue;
|
|
|
|
/**
|
|
* Distance between the increment button and the track. This may be a negative
|
|
* number. If negative, then an overlap between the button and track will occur,
|
|
* which is useful for shaped buttons.
|
|
*
|
|
* @since 1.7
|
|
*/
|
|
protected int incrGap;
|
|
|
|
/**
|
|
* Distance between the decrement button and the track. This may be a negative
|
|
* number. If negative, then an overlap between the button and track will occur,
|
|
* which is useful for shaped buttons.
|
|
*
|
|
* @since 1.7
|
|
*/
|
|
protected int decrGap;
|
|
|
|
static void loadActionMap(LazyActionMap map) {
|
|
map.put(new Actions(Actions.POSITIVE_UNIT_INCREMENT));
|
|
map.put(new Actions(Actions.POSITIVE_BLOCK_INCREMENT));
|
|
map.put(new Actions(Actions.NEGATIVE_UNIT_INCREMENT));
|
|
map.put(new Actions(Actions.NEGATIVE_BLOCK_INCREMENT));
|
|
map.put(new Actions(Actions.MIN_SCROLL));
|
|
map.put(new Actions(Actions.MAX_SCROLL));
|
|
}
|
|
|
|
|
|
public static ComponentUI createUI(JComponent c) {
|
|
return new BasicScrollBarUI();
|
|
}
|
|
|
|
|
|
protected void configureScrollBarColors()
|
|
{
|
|
LookAndFeel.installColors(scrollbar, "ScrollBar.background",
|
|
"ScrollBar.foreground");
|
|
thumbHighlightColor = UIManager.getColor("ScrollBar.thumbHighlight");
|
|
thumbLightShadowColor = UIManager.getColor("ScrollBar.thumbShadow");
|
|
thumbDarkShadowColor = UIManager.getColor("ScrollBar.thumbDarkShadow");
|
|
thumbColor = UIManager.getColor("ScrollBar.thumb");
|
|
trackColor = UIManager.getColor("ScrollBar.track");
|
|
trackHighlightColor = UIManager.getColor("ScrollBar.trackHighlight");
|
|
}
|
|
|
|
|
|
public void installUI(JComponent c) {
|
|
scrollbar = (JScrollBar)c;
|
|
thumbRect = new Rectangle(0, 0, 0, 0);
|
|
trackRect = new Rectangle(0, 0, 0, 0);
|
|
installDefaults();
|
|
installComponents();
|
|
installListeners();
|
|
installKeyboardActions();
|
|
}
|
|
|
|
public void uninstallUI(JComponent c) {
|
|
scrollbar = (JScrollBar)c;
|
|
uninstallListeners();
|
|
uninstallDefaults();
|
|
uninstallComponents();
|
|
uninstallKeyboardActions();
|
|
thumbRect = null;
|
|
scrollbar = null;
|
|
incrButton = null;
|
|
decrButton = null;
|
|
}
|
|
|
|
|
|
protected void installDefaults()
|
|
{
|
|
scrollBarWidth = UIManager.getInt("ScrollBar.width");
|
|
if (scrollBarWidth <= 0) {
|
|
scrollBarWidth = 16;
|
|
}
|
|
minimumThumbSize = (Dimension)UIManager.get("ScrollBar.minimumThumbSize");
|
|
maximumThumbSize = (Dimension)UIManager.get("ScrollBar.maximumThumbSize");
|
|
|
|
Boolean absB = (Boolean)UIManager.get("ScrollBar.allowsAbsolutePositioning");
|
|
supportsAbsolutePositioning = (absB != null) ? absB.booleanValue() :
|
|
false;
|
|
|
|
trackHighlight = NO_HIGHLIGHT;
|
|
if (scrollbar.getLayout() == null ||
|
|
(scrollbar.getLayout() instanceof UIResource)) {
|
|
scrollbar.setLayout(this);
|
|
}
|
|
configureScrollBarColors();
|
|
LookAndFeel.installBorder(scrollbar, "ScrollBar.border");
|
|
LookAndFeel.installProperty(scrollbar, "opaque", Boolean.TRUE);
|
|
|
|
scrollBarValue = scrollbar.getValue();
|
|
|
|
incrGap = UIManager.getInt("ScrollBar.incrementButtonGap");
|
|
decrGap = UIManager.getInt("ScrollBar.decrementButtonGap");
|
|
|
|
// TODO this can be removed when incrGap/decrGap become protected
|
|
// handle scaling for sizeVarients for special case components. The
|
|
// key "JComponent.sizeVariant" scales for large/small/mini
|
|
// components are based on Apples LAF
|
|
String scaleKey = (String)scrollbar.getClientProperty(
|
|
"JComponent.sizeVariant");
|
|
if (scaleKey != null){
|
|
if ("large".equals(scaleKey)){
|
|
scrollBarWidth *= 1.15;
|
|
incrGap *= 1.15;
|
|
decrGap *= 1.15;
|
|
} else if ("small".equals(scaleKey)){
|
|
scrollBarWidth *= 0.857;
|
|
incrGap *= 0.857;
|
|
decrGap *= 0.714;
|
|
} else if ("mini".equals(scaleKey)){
|
|
scrollBarWidth *= 0.714;
|
|
incrGap *= 0.714;
|
|
decrGap *= 0.714;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
protected void installComponents(){
|
|
switch (scrollbar.getOrientation()) {
|
|
case JScrollBar.VERTICAL:
|
|
incrButton = createIncreaseButton(SOUTH);
|
|
decrButton = createDecreaseButton(NORTH);
|
|
break;
|
|
|
|
case JScrollBar.HORIZONTAL:
|
|
if (scrollbar.getComponentOrientation().isLeftToRight()) {
|
|
incrButton = createIncreaseButton(EAST);
|
|
decrButton = createDecreaseButton(WEST);
|
|
} else {
|
|
incrButton = createIncreaseButton(WEST);
|
|
decrButton = createDecreaseButton(EAST);
|
|
}
|
|
break;
|
|
}
|
|
scrollbar.add(incrButton);
|
|
scrollbar.add(decrButton);
|
|
// Force the children's enabled state to be updated.
|
|
scrollbar.setEnabled(scrollbar.isEnabled());
|
|
}
|
|
|
|
protected void uninstallComponents(){
|
|
scrollbar.remove(incrButton);
|
|
scrollbar.remove(decrButton);
|
|
}
|
|
|
|
|
|
protected void installListeners(){
|
|
trackListener = createTrackListener();
|
|
buttonListener = createArrowButtonListener();
|
|
modelListener = createModelListener();
|
|
propertyChangeListener = createPropertyChangeListener();
|
|
|
|
scrollbar.addMouseListener(trackListener);
|
|
scrollbar.addMouseMotionListener(trackListener);
|
|
scrollbar.getModel().addChangeListener(modelListener);
|
|
scrollbar.addPropertyChangeListener(propertyChangeListener);
|
|
scrollbar.addFocusListener(getHandler());
|
|
|
|
if (incrButton != null) {
|
|
incrButton.addMouseListener(buttonListener);
|
|
}
|
|
if (decrButton != null) {
|
|
decrButton.addMouseListener(buttonListener);
|
|
}
|
|
|
|
scrollListener = createScrollListener();
|
|
scrollTimer = new Timer(scrollSpeedThrottle, scrollListener);
|
|
scrollTimer.setInitialDelay(300); // default InitialDelay?
|
|
}
|
|
|
|
|
|
protected void installKeyboardActions(){
|
|
LazyActionMap.installLazyActionMap(scrollbar, BasicScrollBarUI.class,
|
|
"ScrollBar.actionMap");
|
|
|
|
InputMap inputMap = getInputMap(JComponent.WHEN_FOCUSED);
|
|
SwingUtilities.replaceUIInputMap(scrollbar, JComponent.WHEN_FOCUSED,
|
|
inputMap);
|
|
inputMap = getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
|
|
SwingUtilities.replaceUIInputMap(scrollbar,
|
|
JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, inputMap);
|
|
}
|
|
|
|
protected void uninstallKeyboardActions(){
|
|
SwingUtilities.replaceUIInputMap(scrollbar, JComponent.WHEN_FOCUSED,
|
|
null);
|
|
SwingUtilities.replaceUIActionMap(scrollbar, null);
|
|
}
|
|
|
|
private InputMap getInputMap(int condition) {
|
|
if (condition == JComponent.WHEN_FOCUSED) {
|
|
InputMap keyMap = (InputMap)DefaultLookup.get(
|
|
scrollbar, this, "ScrollBar.focusInputMap");
|
|
InputMap rtlKeyMap;
|
|
|
|
if (scrollbar.getComponentOrientation().isLeftToRight() ||
|
|
((rtlKeyMap = (InputMap)DefaultLookup.get(scrollbar, this, "ScrollBar.focusInputMap.RightToLeft")) == null)) {
|
|
return keyMap;
|
|
} else {
|
|
rtlKeyMap.setParent(keyMap);
|
|
return rtlKeyMap;
|
|
}
|
|
}
|
|
else if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT) {
|
|
InputMap keyMap = (InputMap)DefaultLookup.get(
|
|
scrollbar, this, "ScrollBar.ancestorInputMap");
|
|
InputMap rtlKeyMap;
|
|
|
|
if (scrollbar.getComponentOrientation().isLeftToRight() ||
|
|
((rtlKeyMap = (InputMap)DefaultLookup.get(scrollbar, this, "ScrollBar.ancestorInputMap.RightToLeft")) == null)) {
|
|
return keyMap;
|
|
} else {
|
|
rtlKeyMap.setParent(keyMap);
|
|
return rtlKeyMap;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
|
|
protected void uninstallListeners() {
|
|
scrollTimer.stop();
|
|
scrollTimer = null;
|
|
|
|
if (decrButton != null){
|
|
decrButton.removeMouseListener(buttonListener);
|
|
}
|
|
if (incrButton != null){
|
|
incrButton.removeMouseListener(buttonListener);
|
|
}
|
|
|
|
scrollbar.getModel().removeChangeListener(modelListener);
|
|
scrollbar.removeMouseListener(trackListener);
|
|
scrollbar.removeMouseMotionListener(trackListener);
|
|
scrollbar.removePropertyChangeListener(propertyChangeListener);
|
|
scrollbar.removeFocusListener(getHandler());
|
|
handler = null;
|
|
}
|
|
|
|
|
|
protected void uninstallDefaults(){
|
|
LookAndFeel.uninstallBorder(scrollbar);
|
|
if (scrollbar.getLayout() == this) {
|
|
scrollbar.setLayout(null);
|
|
}
|
|
}
|
|
|
|
|
|
private Handler getHandler() {
|
|
if (handler == null) {
|
|
handler = new Handler();
|
|
}
|
|
return handler;
|
|
}
|
|
|
|
protected TrackListener createTrackListener(){
|
|
return new TrackListener();
|
|
}
|
|
|
|
protected ArrowButtonListener createArrowButtonListener(){
|
|
return new ArrowButtonListener();
|
|
}
|
|
|
|
protected ModelListener createModelListener(){
|
|
return new ModelListener();
|
|
}
|
|
|
|
protected ScrollListener createScrollListener(){
|
|
return new ScrollListener();
|
|
}
|
|
|
|
protected PropertyChangeListener createPropertyChangeListener() {
|
|
return getHandler();
|
|
}
|
|
|
|
private void updateThumbState(int x, int y) {
|
|
Rectangle rect = getThumbBounds();
|
|
|
|
setThumbRollover(rect.contains(x, y));
|
|
}
|
|
|
|
/**
|
|
* Sets whether or not the mouse is currently over the thumb.
|
|
*
|
|
* @param active True indicates the thumb is currently active.
|
|
* @since 1.5
|
|
*/
|
|
protected void setThumbRollover(boolean active) {
|
|
if (thumbActive != active) {
|
|
thumbActive = active;
|
|
scrollbar.repaint(getThumbBounds());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if the mouse is currently over the thumb.
|
|
*
|
|
* @return true if the thumb is currently active
|
|
* @since 1.5
|
|
*/
|
|
public boolean isThumbRollover() {
|
|
return thumbActive;
|
|
}
|
|
|
|
public void paint(Graphics g, JComponent c) {
|
|
paintTrack(g, c, getTrackBounds());
|
|
Rectangle thumbBounds = getThumbBounds();
|
|
if (thumbBounds.intersects(g.getClipBounds())) {
|
|
paintThumb(g, c, thumbBounds);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* A vertical scrollbar's preferred width is the maximum of
|
|
* preferred widths of the (non <code>null</code>)
|
|
* increment/decrement buttons,
|
|
* and the minimum width of the thumb. The preferred height is the
|
|
* sum of the preferred heights of the same parts. The basis for
|
|
* the preferred size of a horizontal scrollbar is similar.
|
|
* <p>
|
|
* The <code>preferredSize</code> is only computed once, subsequent
|
|
* calls to this method just return a cached size.
|
|
*
|
|
* @param c the <code>JScrollBar</code> that's delegating this method to us
|
|
* @return the preferred size of a Basic JScrollBar
|
|
* @see #getMaximumSize
|
|
* @see #getMinimumSize
|
|
*/
|
|
public Dimension getPreferredSize(JComponent c) {
|
|
return (scrollbar.getOrientation() == JScrollBar.VERTICAL)
|
|
? new Dimension(scrollBarWidth, 48)
|
|
: new Dimension(48, scrollBarWidth);
|
|
}
|
|
|
|
|
|
/**
|
|
* @param c The JScrollBar that's delegating this method to us.
|
|
* @return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
|
|
* @see #getMinimumSize
|
|
* @see #getPreferredSize
|
|
*/
|
|
public Dimension getMaximumSize(JComponent c) {
|
|
return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
|
|
}
|
|
|
|
protected JButton createDecreaseButton(int orientation) {
|
|
return new BasicArrowButton(orientation,
|
|
UIManager.getColor("ScrollBar.thumb"),
|
|
UIManager.getColor("ScrollBar.thumbShadow"),
|
|
UIManager.getColor("ScrollBar.thumbDarkShadow"),
|
|
UIManager.getColor("ScrollBar.thumbHighlight"));
|
|
}
|
|
|
|
protected JButton createIncreaseButton(int orientation) {
|
|
return new BasicArrowButton(orientation,
|
|
UIManager.getColor("ScrollBar.thumb"),
|
|
UIManager.getColor("ScrollBar.thumbShadow"),
|
|
UIManager.getColor("ScrollBar.thumbDarkShadow"),
|
|
UIManager.getColor("ScrollBar.thumbHighlight"));
|
|
}
|
|
|
|
|
|
protected void paintDecreaseHighlight(Graphics g)
|
|
{
|
|
Insets insets = scrollbar.getInsets();
|
|
Rectangle thumbR = getThumbBounds();
|
|
g.setColor(trackHighlightColor);
|
|
|
|
if (scrollbar.getOrientation() == JScrollBar.VERTICAL) {
|
|
//paint the distance between the start of the track and top of the thumb
|
|
int x = insets.left;
|
|
int y = trackRect.y;
|
|
int w = scrollbar.getWidth() - (insets.left + insets.right);
|
|
int h = thumbR.y - y;
|
|
g.fillRect(x, y, w, h);
|
|
} else {
|
|
//if left-to-right, fill the area between the start of the track and
|
|
//the left edge of the thumb. If right-to-left, fill the area between
|
|
//the end of the thumb and end of the track.
|
|
int x, w;
|
|
if (scrollbar.getComponentOrientation().isLeftToRight()) {
|
|
x = trackRect.x;
|
|
w = thumbR.x - x;
|
|
} else {
|
|
x = thumbR.x + thumbR.width;
|
|
w = trackRect.x + trackRect.width - x;
|
|
}
|
|
int y = insets.top;
|
|
int h = scrollbar.getHeight() - (insets.top + insets.bottom);
|
|
g.fillRect(x, y, w, h);
|
|
}
|
|
}
|
|
|
|
|
|
protected void paintIncreaseHighlight(Graphics g)
|
|
{
|
|
Insets insets = scrollbar.getInsets();
|
|
Rectangle thumbR = getThumbBounds();
|
|
g.setColor(trackHighlightColor);
|
|
|
|
if (scrollbar.getOrientation() == JScrollBar.VERTICAL) {
|
|
//fill the area between the bottom of the thumb and the end of the track.
|
|
int x = insets.left;
|
|
int y = thumbR.y + thumbR.height;
|
|
int w = scrollbar.getWidth() - (insets.left + insets.right);
|
|
int h = trackRect.y + trackRect.height - y;
|
|
g.fillRect(x, y, w, h);
|
|
}
|
|
else {
|
|
//if left-to-right, fill the area between the right of the thumb and the
|
|
//end of the track. If right-to-left, then fill the area to the left of
|
|
//the thumb and the start of the track.
|
|
int x, w;
|
|
if (scrollbar.getComponentOrientation().isLeftToRight()) {
|
|
x = thumbR.x + thumbR.width;
|
|
w = trackRect.x + trackRect.width - x;
|
|
} else {
|
|
x = trackRect.x;
|
|
w = thumbR.x - x;
|
|
}
|
|
int y = insets.top;
|
|
int h = scrollbar.getHeight() - (insets.top + insets.bottom);
|
|
g.fillRect(x, y, w, h);
|
|
}
|
|
}
|
|
|
|
|
|
protected void paintTrack(Graphics g, JComponent c, Rectangle trackBounds)
|
|
{
|
|
g.setColor(trackColor);
|
|
g.fillRect(trackBounds.x, trackBounds.y, trackBounds.width, trackBounds.height);
|
|
|
|
if(trackHighlight == DECREASE_HIGHLIGHT) {
|
|
paintDecreaseHighlight(g);
|
|
}
|
|
else if(trackHighlight == INCREASE_HIGHLIGHT) {
|
|
paintIncreaseHighlight(g);
|
|
}
|
|
}
|
|
|
|
|
|
protected void paintThumb(Graphics g, JComponent c, Rectangle thumbBounds)
|
|
{
|
|
if(thumbBounds.isEmpty() || !scrollbar.isEnabled()) {
|
|
return;
|
|
}
|
|
|
|
int w = thumbBounds.width;
|
|
int h = thumbBounds.height;
|
|
|
|
g.translate(thumbBounds.x, thumbBounds.y);
|
|
|
|
g.setColor(thumbDarkShadowColor);
|
|
drawRect(g, 0, 0, w - 1, h - 1);
|
|
g.setColor(thumbColor);
|
|
g.fillRect(0, 0, w - 1, h - 1);
|
|
|
|
g.setColor(thumbHighlightColor);
|
|
drawVLine(g, 1, 1, h - 2);
|
|
drawHLine(g, 2, w - 3, 1);
|
|
|
|
g.setColor(thumbLightShadowColor);
|
|
drawHLine(g, 2, w - 2, h - 2);
|
|
drawVLine(g, w - 2, 1, h - 3);
|
|
|
|
g.translate(-thumbBounds.x, -thumbBounds.y);
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the smallest acceptable size for the thumb. If the scrollbar
|
|
* becomes so small that this size isn't available, the thumb will be
|
|
* hidden.
|
|
* <p>
|
|
* <b>Warning </b>: the value returned by this method should not be
|
|
* be modified, it's a shared static constant.
|
|
*
|
|
* @return The smallest acceptable size for the thumb.
|
|
* @see #getMaximumThumbSize
|
|
*/
|
|
protected Dimension getMinimumThumbSize() {
|
|
return minimumThumbSize;
|
|
}
|
|
|
|
/**
|
|
* Returns the largest acceptable size for the thumb. To create a fixed
|
|
* size thumb one make this method and <code>getMinimumThumbSize</code>
|
|
* return the same value.
|
|
* <p>
|
|
* <b>Warning </b>: the value returned by this method should not be
|
|
* be modified, it's a shared static constant.
|
|
*
|
|
* @return The largest acceptable size for the thumb.
|
|
* @see #getMinimumThumbSize
|
|
*/
|
|
protected Dimension getMaximumThumbSize() {
|
|
return maximumThumbSize;
|
|
}
|
|
|
|
|
|
/*
|
|
* LayoutManager Implementation
|
|
*/
|
|
|
|
public void addLayoutComponent(String name, Component child) {}
|
|
public void removeLayoutComponent(Component child) {}
|
|
|
|
public Dimension preferredLayoutSize(Container scrollbarContainer) {
|
|
return getPreferredSize((JComponent)scrollbarContainer);
|
|
}
|
|
|
|
public Dimension minimumLayoutSize(Container scrollbarContainer) {
|
|
return getMinimumSize((JComponent)scrollbarContainer);
|
|
}
|
|
|
|
private int getValue(JScrollBar sb) {
|
|
return (useCachedValue) ? scrollBarValue : sb.getValue();
|
|
}
|
|
|
|
protected void layoutVScrollbar(JScrollBar sb)
|
|
{
|
|
Dimension sbSize = sb.getSize();
|
|
Insets sbInsets = sb.getInsets();
|
|
|
|
/*
|
|
* Width and left edge of the buttons and thumb.
|
|
*/
|
|
int itemW = sbSize.width - (sbInsets.left + sbInsets.right);
|
|
int itemX = sbInsets.left;
|
|
|
|
/* Nominal locations of the buttons, assuming their preferred
|
|
* size will fit.
|
|
*/
|
|
boolean squareButtons = DefaultLookup.getBoolean(
|
|
scrollbar, this, "ScrollBar.squareButtons", false);
|
|
int decrButtonH = squareButtons ? itemW :
|
|
decrButton.getPreferredSize().height;
|
|
int decrButtonY = sbInsets.top;
|
|
|
|
int incrButtonH = squareButtons ? itemW :
|
|
incrButton.getPreferredSize().height;
|
|
int incrButtonY = sbSize.height - (sbInsets.bottom + incrButtonH);
|
|
|
|
/* The thumb must fit within the height left over after we
|
|
* subtract the preferredSize of the buttons and the insets
|
|
* and the gaps
|
|
*/
|
|
int sbInsetsH = sbInsets.top + sbInsets.bottom;
|
|
int sbButtonsH = decrButtonH + incrButtonH;
|
|
int gaps = decrGap + incrGap;
|
|
float trackH = sbSize.height - (sbInsetsH + sbButtonsH) - gaps;
|
|
|
|
/* Compute the height and origin of the thumb. The case
|
|
* where the thumb is at the bottom edge is handled specially
|
|
* to avoid numerical problems in computing thumbY. Enforce
|
|
* the thumbs min/max dimensions. If the thumb doesn't
|
|
* fit in the track (trackH) we'll hide it later.
|
|
*/
|
|
float min = sb.getMinimum();
|
|
float extent = sb.getVisibleAmount();
|
|
float range = sb.getMaximum() - min;
|
|
float value = getValue(sb);
|
|
|
|
int thumbH = (range <= 0)
|
|
? getMaximumThumbSize().height : (int)(trackH * (extent / range));
|
|
thumbH = Math.max(thumbH, getMinimumThumbSize().height);
|
|
thumbH = Math.min(thumbH, getMaximumThumbSize().height);
|
|
|
|
int thumbY = incrButtonY - incrGap - thumbH;
|
|
if (value < (sb.getMaximum() - sb.getVisibleAmount())) {
|
|
float thumbRange = trackH - thumbH;
|
|
thumbY = (int)(0.5f + (thumbRange * ((value - min) / (range - extent))));
|
|
thumbY += decrButtonY + decrButtonH + decrGap;
|
|
}
|
|
|
|
/* If the buttons don't fit, allocate half of the available
|
|
* space to each and move the lower one (incrButton) down.
|
|
*/
|
|
int sbAvailButtonH = (sbSize.height - sbInsetsH);
|
|
if (sbAvailButtonH < sbButtonsH) {
|
|
incrButtonH = decrButtonH = sbAvailButtonH / 2;
|
|
incrButtonY = sbSize.height - (sbInsets.bottom + incrButtonH);
|
|
}
|
|
decrButton.setBounds(itemX, decrButtonY, itemW, decrButtonH);
|
|
incrButton.setBounds(itemX, incrButtonY, itemW, incrButtonH);
|
|
|
|
/* Update the trackRect field.
|
|
*/
|
|
int itrackY = decrButtonY + decrButtonH + decrGap;
|
|
int itrackH = incrButtonY - incrGap - itrackY;
|
|
trackRect.setBounds(itemX, itrackY, itemW, itrackH);
|
|
|
|
/* If the thumb isn't going to fit, zero it's bounds. Otherwise
|
|
* make sure it fits between the buttons. Note that setting the
|
|
* thumbs bounds will cause a repaint.
|
|
*/
|
|
if(thumbH >= (int)trackH) {
|
|
if (UIManager.getBoolean("ScrollBar.alwaysShowThumb")) {
|
|
// This is used primarily for GTK L&F, which expands the
|
|
// thumb to fit the track when it would otherwise be hidden.
|
|
setThumbBounds(itemX, itrackY, itemW, itrackH);
|
|
} else {
|
|
// Other L&F's simply hide the thumb in this case.
|
|
setThumbBounds(0, 0, 0, 0);
|
|
}
|
|
}
|
|
else {
|
|
if ((thumbY + thumbH) > incrButtonY - incrGap) {
|
|
thumbY = incrButtonY - incrGap - thumbH;
|
|
}
|
|
if (thumbY < (decrButtonY + decrButtonH + decrGap)) {
|
|
thumbY = decrButtonY + decrButtonH + decrGap + 1;
|
|
}
|
|
setThumbBounds(itemX, thumbY, itemW, thumbH);
|
|
}
|
|
}
|
|
|
|
|
|
protected void layoutHScrollbar(JScrollBar sb)
|
|
{
|
|
Dimension sbSize = sb.getSize();
|
|
Insets sbInsets = sb.getInsets();
|
|
|
|
/* Height and top edge of the buttons and thumb.
|
|
*/
|
|
int itemH = sbSize.height - (sbInsets.top + sbInsets.bottom);
|
|
int itemY = sbInsets.top;
|
|
|
|
boolean ltr = sb.getComponentOrientation().isLeftToRight();
|
|
|
|
/* Nominal locations of the buttons, assuming their preferred
|
|
* size will fit.
|
|
*/
|
|
boolean squareButtons = DefaultLookup.getBoolean(
|
|
scrollbar, this, "ScrollBar.squareButtons", false);
|
|
int leftButtonW = squareButtons ? itemH :
|
|
decrButton.getPreferredSize().width;
|
|
int rightButtonW = squareButtons ? itemH :
|
|
incrButton.getPreferredSize().width;
|
|
if (!ltr) {
|
|
int temp = leftButtonW;
|
|
leftButtonW = rightButtonW;
|
|
rightButtonW = temp;
|
|
}
|
|
int leftButtonX = sbInsets.left;
|
|
int rightButtonX = sbSize.width - (sbInsets.right + rightButtonW);
|
|
int leftGap = ltr ? decrGap : incrGap;
|
|
int rightGap = ltr ? incrGap : decrGap;
|
|
|
|
/* The thumb must fit within the width left over after we
|
|
* subtract the preferredSize of the buttons and the insets
|
|
* and the gaps
|
|
*/
|
|
int sbInsetsW = sbInsets.left + sbInsets.right;
|
|
int sbButtonsW = leftButtonW + rightButtonW;
|
|
float trackW = sbSize.width - (sbInsetsW + sbButtonsW) - (leftGap + rightGap);
|
|
|
|
/* Compute the width and origin of the thumb. Enforce
|
|
* the thumbs min/max dimensions. The case where the thumb
|
|
* is at the right edge is handled specially to avoid numerical
|
|
* problems in computing thumbX. If the thumb doesn't
|
|
* fit in the track (trackH) we'll hide it later.
|
|
*/
|
|
float min = sb.getMinimum();
|
|
float max = sb.getMaximum();
|
|
float extent = sb.getVisibleAmount();
|
|
float range = max - min;
|
|
float value = getValue(sb);
|
|
|
|
int thumbW = (range <= 0)
|
|
? getMaximumThumbSize().width : (int)(trackW * (extent / range));
|
|
thumbW = Math.max(thumbW, getMinimumThumbSize().width);
|
|
thumbW = Math.min(thumbW, getMaximumThumbSize().width);
|
|
|
|
int thumbX = ltr ? rightButtonX - rightGap - thumbW : leftButtonX + leftButtonW + leftGap;
|
|
if (value < (max - sb.getVisibleAmount())) {
|
|
float thumbRange = trackW - thumbW;
|
|
if( ltr ) {
|
|
thumbX = (int)(0.5f + (thumbRange * ((value - min) / (range - extent))));
|
|
} else {
|
|
thumbX = (int)(0.5f + (thumbRange * ((max - extent - value) / (range - extent))));
|
|
}
|
|
thumbX += leftButtonX + leftButtonW + leftGap;
|
|
}
|
|
|
|
/* If the buttons don't fit, allocate half of the available
|
|
* space to each and move the right one over.
|
|
*/
|
|
int sbAvailButtonW = (sbSize.width - sbInsetsW);
|
|
if (sbAvailButtonW < sbButtonsW) {
|
|
rightButtonW = leftButtonW = sbAvailButtonW / 2;
|
|
rightButtonX = sbSize.width - (sbInsets.right + rightButtonW + rightGap);
|
|
}
|
|
|
|
(ltr ? decrButton : incrButton).setBounds(leftButtonX, itemY, leftButtonW, itemH);
|
|
(ltr ? incrButton : decrButton).setBounds(rightButtonX, itemY, rightButtonW, itemH);
|
|
|
|
/* Update the trackRect field.
|
|
*/
|
|
int itrackX = leftButtonX + leftButtonW + leftGap;
|
|
int itrackW = rightButtonX - rightGap - itrackX;
|
|
trackRect.setBounds(itrackX, itemY, itrackW, itemH);
|
|
|
|
/* Make sure the thumb fits between the buttons. Note
|
|
* that setting the thumbs bounds causes a repaint.
|
|
*/
|
|
if (thumbW >= (int)trackW) {
|
|
if (UIManager.getBoolean("ScrollBar.alwaysShowThumb")) {
|
|
// This is used primarily for GTK L&F, which expands the
|
|
// thumb to fit the track when it would otherwise be hidden.
|
|
setThumbBounds(itrackX, itemY, itrackW, itemH);
|
|
} else {
|
|
// Other L&F's simply hide the thumb in this case.
|
|
setThumbBounds(0, 0, 0, 0);
|
|
}
|
|
}
|
|
else {
|
|
if (thumbX + thumbW > rightButtonX - rightGap) {
|
|
thumbX = rightButtonX - rightGap - thumbW;
|
|
}
|
|
if (thumbX < leftButtonX + leftButtonW + leftGap) {
|
|
thumbX = leftButtonX + leftButtonW + leftGap + 1;
|
|
}
|
|
setThumbBounds(thumbX, itemY, thumbW, itemH);
|
|
}
|
|
}
|
|
|
|
public void layoutContainer(Container scrollbarContainer)
|
|
{
|
|
/* If the user is dragging the value, we'll assume that the
|
|
* scrollbars layout is OK modulo the thumb which is being
|
|
* handled by the dragging code.
|
|
*/
|
|
if (isDragging) {
|
|
return;
|
|
}
|
|
|
|
JScrollBar scrollbar = (JScrollBar)scrollbarContainer;
|
|
switch (scrollbar.getOrientation()) {
|
|
case JScrollBar.VERTICAL:
|
|
layoutVScrollbar(scrollbar);
|
|
break;
|
|
|
|
case JScrollBar.HORIZONTAL:
|
|
layoutHScrollbar(scrollbar);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Set the bounds of the thumb and force a repaint that includes
|
|
* the old thumbBounds and the new one.
|
|
*
|
|
* @see #getThumbBounds
|
|
*/
|
|
protected void setThumbBounds(int x, int y, int width, int height)
|
|
{
|
|
/* If the thumbs bounds haven't changed, we're done.
|
|
*/
|
|
if ((thumbRect.x == x) &&
|
|
(thumbRect.y == y) &&
|
|
(thumbRect.width == width) &&
|
|
(thumbRect.height == height)) {
|
|
return;
|
|
}
|
|
|
|
/* Update thumbRect, and repaint the union of x,y,w,h and
|
|
* the old thumbRect.
|
|
*/
|
|
int minX = Math.min(x, thumbRect.x);
|
|
int minY = Math.min(y, thumbRect.y);
|
|
int maxX = Math.max(x + width, thumbRect.x + thumbRect.width);
|
|
int maxY = Math.max(y + height, thumbRect.y + thumbRect.height);
|
|
|
|
thumbRect.setBounds(x, y, width, height);
|
|
scrollbar.repaint(minX, minY, maxX - minX, maxY - minY);
|
|
|
|
// Once there is API to determine the mouse location this will need
|
|
// to be changed.
|
|
setThumbRollover(false);
|
|
}
|
|
|
|
|
|
/**
|
|
* Return the current size/location of the thumb.
|
|
* <p>
|
|
* <b>Warning </b>: the value returned by this method should not be
|
|
* be modified, it's a reference to the actual rectangle, not a copy.
|
|
*
|
|
* @return The current size/location of the thumb.
|
|
* @see #setThumbBounds
|
|
*/
|
|
protected Rectangle getThumbBounds() {
|
|
return thumbRect;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the current bounds of the track, i.e. the space in between
|
|
* the increment and decrement buttons, less the insets. The value
|
|
* returned by this method is updated each time the scrollbar is
|
|
* laid out (validated).
|
|
* <p>
|
|
* <b>Warning </b>: the value returned by this method should not be
|
|
* be modified, it's a reference to the actual rectangle, not a copy.
|
|
*
|
|
* @return the current bounds of the scrollbar track
|
|
* @see #layoutContainer
|
|
*/
|
|
protected Rectangle getTrackBounds() {
|
|
return trackRect;
|
|
}
|
|
|
|
/*
|
|
* Method for scrolling by a block increment.
|
|
* Added for mouse wheel scrolling support, RFE 4202656.
|
|
*/
|
|
static void scrollByBlock(JScrollBar scrollbar, int direction) {
|
|
// This method is called from BasicScrollPaneUI to implement wheel
|
|
// scrolling, and also from scrollByBlock().
|
|
int oldValue = scrollbar.getValue();
|
|
int blockIncrement = scrollbar.getBlockIncrement(direction);
|
|
int delta = blockIncrement * ((direction > 0) ? +1 : -1);
|
|
int newValue = oldValue + delta;
|
|
|
|
// Check for overflow.
|
|
if (delta > 0 && newValue < oldValue) {
|
|
newValue = scrollbar.getMaximum();
|
|
}
|
|
else if (delta < 0 && newValue > oldValue) {
|
|
newValue = scrollbar.getMinimum();
|
|
}
|
|
|
|
scrollbar.setValue(newValue);
|
|
}
|
|
|
|
protected void scrollByBlock(int direction)
|
|
{
|
|
scrollByBlock(scrollbar, direction);
|
|
trackHighlight = direction > 0 ? INCREASE_HIGHLIGHT : DECREASE_HIGHLIGHT;
|
|
Rectangle dirtyRect = getTrackBounds();
|
|
scrollbar.repaint(dirtyRect.x, dirtyRect.y, dirtyRect.width, dirtyRect.height);
|
|
}
|
|
|
|
/*
|
|
* Method for scrolling by a unit increment.
|
|
* Added for mouse wheel scrolling support, RFE 4202656.
|
|
*
|
|
* If limitByBlock is set to true, the scrollbar will scroll at least 1
|
|
* unit increment, but will not scroll farther than the block increment.
|
|
* See BasicScrollPaneUI.Handler.mouseWheelMoved().
|
|
*/
|
|
static void scrollByUnits(JScrollBar scrollbar, int direction,
|
|
int units, boolean limitToBlock) {
|
|
// This method is called from BasicScrollPaneUI to implement wheel
|
|
// scrolling, as well as from scrollByUnit().
|
|
int delta;
|
|
int limit = -1;
|
|
|
|
if (limitToBlock) {
|
|
if (direction < 0) {
|
|
limit = scrollbar.getValue() -
|
|
scrollbar.getBlockIncrement(direction);
|
|
}
|
|
else {
|
|
limit = scrollbar.getValue() +
|
|
scrollbar.getBlockIncrement(direction);
|
|
}
|
|
}
|
|
|
|
for (int i=0; i<units; i++) {
|
|
if (direction > 0) {
|
|
delta = scrollbar.getUnitIncrement(direction);
|
|
}
|
|
else {
|
|
delta = -scrollbar.getUnitIncrement(direction);
|
|
}
|
|
|
|
int oldValue = scrollbar.getValue();
|
|
int newValue = oldValue + delta;
|
|
|
|
// Check for overflow.
|
|
if (delta > 0 && newValue < oldValue) {
|
|
newValue = scrollbar.getMaximum();
|
|
}
|
|
else if (delta < 0 && newValue > oldValue) {
|
|
newValue = scrollbar.getMinimum();
|
|
}
|
|
if (oldValue == newValue) {
|
|
break;
|
|
}
|
|
|
|
if (limitToBlock && i > 0) {
|
|
assert limit != -1;
|
|
if ((direction < 0 && newValue < limit) ||
|
|
(direction > 0 && newValue > limit)) {
|
|
break;
|
|
}
|
|
}
|
|
scrollbar.setValue(newValue);
|
|
}
|
|
}
|
|
|
|
protected void scrollByUnit(int direction) {
|
|
scrollByUnits(scrollbar, direction, 1, false);
|
|
}
|
|
|
|
/**
|
|
* Indicates whether the user can absolutely position the thumb with
|
|
* a mouse gesture (usually the middle mouse button).
|
|
*
|
|
* @return true if a mouse gesture can absolutely position the thumb
|
|
* @since 1.5
|
|
*/
|
|
public boolean getSupportsAbsolutePositioning() {
|
|
return supportsAbsolutePositioning;
|
|
}
|
|
|
|
/**
|
|
* A listener to listen for model changes.
|
|
*
|
|
*/
|
|
protected class ModelListener implements ChangeListener {
|
|
public void stateChanged(ChangeEvent e) {
|
|
if (!useCachedValue) {
|
|
scrollBarValue = scrollbar.getValue();
|
|
}
|
|
layoutContainer(scrollbar);
|
|
useCachedValue = false;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Track mouse drags.
|
|
*/
|
|
protected class TrackListener
|
|
extends MouseAdapter implements MouseMotionListener
|
|
{
|
|
protected transient int offset;
|
|
protected transient int currentMouseX, currentMouseY;
|
|
private transient int direction = +1;
|
|
|
|
public void mouseReleased(MouseEvent e)
|
|
{
|
|
if (isDragging) {
|
|
updateThumbState(e.getX(), e.getY());
|
|
}
|
|
if (SwingUtilities.isRightMouseButton(e) ||
|
|
(!getSupportsAbsolutePositioning() &&
|
|
SwingUtilities.isMiddleMouseButton(e)))
|
|
return;
|
|
if(!scrollbar.isEnabled())
|
|
return;
|
|
|
|
Rectangle r = getTrackBounds();
|
|
scrollbar.repaint(r.x, r.y, r.width, r.height);
|
|
|
|
trackHighlight = NO_HIGHLIGHT;
|
|
isDragging = false;
|
|
offset = 0;
|
|
scrollTimer.stop();
|
|
useCachedValue = true;
|
|
scrollbar.setValueIsAdjusting(false);
|
|
}
|
|
|
|
|
|
/**
|
|
* If the mouse is pressed above the "thumb" component
|
|
* then reduce the scrollbars value by one page ("page up"),
|
|
* otherwise increase it by one page. If there is no
|
|
* thumb then page up if the mouse is in the upper half
|
|
* of the track.
|
|
*/
|
|
public void mousePressed(MouseEvent e)
|
|
{
|
|
if (SwingUtilities.isRightMouseButton(e) ||
|
|
(!getSupportsAbsolutePositioning() &&
|
|
SwingUtilities.isMiddleMouseButton(e)))
|
|
return;
|
|
if(!scrollbar.isEnabled())
|
|
return;
|
|
|
|
if (!scrollbar.hasFocus() && scrollbar.isRequestFocusEnabled()) {
|
|
scrollbar.requestFocus();
|
|
}
|
|
|
|
useCachedValue = true;
|
|
scrollbar.setValueIsAdjusting(true);
|
|
|
|
currentMouseX = e.getX();
|
|
currentMouseY = e.getY();
|
|
|
|
// Clicked in the Thumb area?
|
|
if(getThumbBounds().contains(currentMouseX, currentMouseY)) {
|
|
switch (scrollbar.getOrientation()) {
|
|
case JScrollBar.VERTICAL:
|
|
offset = currentMouseY - getThumbBounds().y;
|
|
break;
|
|
case JScrollBar.HORIZONTAL:
|
|
offset = currentMouseX - getThumbBounds().x;
|
|
break;
|
|
}
|
|
isDragging = true;
|
|
return;
|
|
}
|
|
else if (getSupportsAbsolutePositioning() &&
|
|
SwingUtilities.isMiddleMouseButton(e)) {
|
|
switch (scrollbar.getOrientation()) {
|
|
case JScrollBar.VERTICAL:
|
|
offset = getThumbBounds().height / 2;
|
|
break;
|
|
case JScrollBar.HORIZONTAL:
|
|
offset = getThumbBounds().width / 2;
|
|
break;
|
|
}
|
|
isDragging = true;
|
|
setValueFrom(e);
|
|
return;
|
|
}
|
|
isDragging = false;
|
|
|
|
Dimension sbSize = scrollbar.getSize();
|
|
direction = +1;
|
|
|
|
switch (scrollbar.getOrientation()) {
|
|
case JScrollBar.VERTICAL:
|
|
if (getThumbBounds().isEmpty()) {
|
|
int scrollbarCenter = sbSize.height / 2;
|
|
direction = (currentMouseY < scrollbarCenter) ? -1 : +1;
|
|
} else {
|
|
int thumbY = getThumbBounds().y;
|
|
direction = (currentMouseY < thumbY) ? -1 : +1;
|
|
}
|
|
break;
|
|
case JScrollBar.HORIZONTAL:
|
|
if (getThumbBounds().isEmpty()) {
|
|
int scrollbarCenter = sbSize.width / 2;
|
|
direction = (currentMouseX < scrollbarCenter) ? -1 : +1;
|
|
} else {
|
|
int thumbX = getThumbBounds().x;
|
|
direction = (currentMouseX < thumbX) ? -1 : +1;
|
|
}
|
|
if (!scrollbar.getComponentOrientation().isLeftToRight()) {
|
|
direction = -direction;
|
|
}
|
|
break;
|
|
}
|
|
scrollByBlock(direction);
|
|
|
|
scrollTimer.stop();
|
|
scrollListener.setDirection(direction);
|
|
scrollListener.setScrollByBlock(true);
|
|
startScrollTimerIfNecessary();
|
|
}
|
|
|
|
|
|
/**
|
|
* Set the models value to the position of the thumb's top of Vertical
|
|
* scrollbar, or the left/right of Horizontal scrollbar in
|
|
* left-to-right/right-to-left scrollbar relative to the origin of the
|
|
* track.
|
|
*/
|
|
public void mouseDragged(MouseEvent e) {
|
|
if (SwingUtilities.isRightMouseButton(e) ||
|
|
(!getSupportsAbsolutePositioning() &&
|
|
SwingUtilities.isMiddleMouseButton(e)))
|
|
return;
|
|
if(!scrollbar.isEnabled() || getThumbBounds().isEmpty()) {
|
|
return;
|
|
}
|
|
if (isDragging) {
|
|
setValueFrom(e);
|
|
} else {
|
|
currentMouseX = e.getX();
|
|
currentMouseY = e.getY();
|
|
updateThumbState(currentMouseX, currentMouseY);
|
|
startScrollTimerIfNecessary();
|
|
}
|
|
}
|
|
|
|
private void setValueFrom(MouseEvent e) {
|
|
boolean active = isThumbRollover();
|
|
BoundedRangeModel model = scrollbar.getModel();
|
|
Rectangle thumbR = getThumbBounds();
|
|
float trackLength;
|
|
int thumbMin, thumbMax, thumbPos;
|
|
|
|
if (scrollbar.getOrientation() == JScrollBar.VERTICAL) {
|
|
thumbMin = trackRect.y;
|
|
thumbMax = trackRect.y + trackRect.height - thumbR.height;
|
|
thumbPos = Math.min(thumbMax, Math.max(thumbMin, (e.getY() - offset)));
|
|
setThumbBounds(thumbR.x, thumbPos, thumbR.width, thumbR.height);
|
|
trackLength = getTrackBounds().height;
|
|
}
|
|
else {
|
|
thumbMin = trackRect.x;
|
|
thumbMax = trackRect.x + trackRect.width - thumbR.width;
|
|
thumbPos = Math.min(thumbMax, Math.max(thumbMin, (e.getX() - offset)));
|
|
setThumbBounds(thumbPos, thumbR.y, thumbR.width, thumbR.height);
|
|
trackLength = getTrackBounds().width;
|
|
}
|
|
|
|
/* Set the scrollbars value. If the thumb has reached the end of
|
|
* the scrollbar, then just set the value to its maximum. Otherwise
|
|
* compute the value as accurately as possible.
|
|
*/
|
|
if (thumbPos == thumbMax) {
|
|
if (scrollbar.getOrientation() == JScrollBar.VERTICAL ||
|
|
scrollbar.getComponentOrientation().isLeftToRight()) {
|
|
scrollbar.setValue(model.getMaximum() - model.getExtent());
|
|
} else {
|
|
scrollbar.setValue(model.getMinimum());
|
|
}
|
|
}
|
|
else {
|
|
float valueMax = model.getMaximum() - model.getExtent();
|
|
float valueRange = valueMax - model.getMinimum();
|
|
float thumbValue = thumbPos - thumbMin;
|
|
float thumbRange = thumbMax - thumbMin;
|
|
int value;
|
|
if (scrollbar.getOrientation() == JScrollBar.VERTICAL ||
|
|
scrollbar.getComponentOrientation().isLeftToRight()) {
|
|
value = (int)(0.5 + ((thumbValue / thumbRange) * valueRange));
|
|
} else {
|
|
value = (int)(0.5 + (((thumbMax - thumbPos) / thumbRange) * valueRange));
|
|
}
|
|
|
|
useCachedValue = true;
|
|
scrollBarValue = value + model.getMinimum();
|
|
scrollbar.setValue(adjustValueIfNecessary(scrollBarValue));
|
|
}
|
|
setThumbRollover(active);
|
|
}
|
|
|
|
private int adjustValueIfNecessary(int value) {
|
|
if (scrollbar.getParent() instanceof JScrollPane) {
|
|
JScrollPane scrollpane = (JScrollPane)scrollbar.getParent();
|
|
JViewport viewport = scrollpane.getViewport();
|
|
Component view = viewport.getView();
|
|
if (view instanceof JList) {
|
|
JList list = (JList)view;
|
|
if (DefaultLookup.getBoolean(list, list.getUI(),
|
|
"List.lockToPositionOnScroll", false)) {
|
|
int adjustedValue = value;
|
|
int mode = list.getLayoutOrientation();
|
|
int orientation = scrollbar.getOrientation();
|
|
if (orientation == JScrollBar.VERTICAL && mode == JList.VERTICAL) {
|
|
int index = list.locationToIndex(new Point(0, value));
|
|
Rectangle rect = list.getCellBounds(index, index);
|
|
if (rect != null) {
|
|
adjustedValue = rect.y;
|
|
}
|
|
}
|
|
if (orientation == JScrollBar.HORIZONTAL &&
|
|
(mode == JList.VERTICAL_WRAP || mode == JList.HORIZONTAL_WRAP)) {
|
|
if (scrollpane.getComponentOrientation().isLeftToRight()) {
|
|
int index = list.locationToIndex(new Point(value, 0));
|
|
Rectangle rect = list.getCellBounds(index, index);
|
|
if (rect != null) {
|
|
adjustedValue = rect.x;
|
|
}
|
|
}
|
|
else {
|
|
Point loc = new Point(value, 0);
|
|
int extent = viewport.getExtentSize().width;
|
|
loc.x += extent - 1;
|
|
int index = list.locationToIndex(loc);
|
|
Rectangle rect = list.getCellBounds(index, index);
|
|
if (rect != null) {
|
|
adjustedValue = rect.x + rect.width - extent;
|
|
}
|
|
}
|
|
}
|
|
value = adjustedValue;
|
|
|
|
}
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
|
|
private void startScrollTimerIfNecessary() {
|
|
if (scrollTimer.isRunning()) {
|
|
return;
|
|
}
|
|
|
|
Rectangle tb = getThumbBounds();
|
|
|
|
switch (scrollbar.getOrientation()) {
|
|
case JScrollBar.VERTICAL:
|
|
if (direction > 0) {
|
|
if (tb.y + tb.height < trackListener.currentMouseY) {
|
|
scrollTimer.start();
|
|
}
|
|
} else if (tb.y > trackListener.currentMouseY) {
|
|
scrollTimer.start();
|
|
}
|
|
break;
|
|
case JScrollBar.HORIZONTAL:
|
|
if ((direction > 0 && isMouseAfterThumb())
|
|
|| (direction < 0 && isMouseBeforeThumb())) {
|
|
|
|
scrollTimer.start();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void mouseMoved(MouseEvent e) {
|
|
if (!isDragging) {
|
|
updateThumbState(e.getX(), e.getY());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Invoked when the mouse exits the scrollbar.
|
|
*
|
|
* @param e MouseEvent further describing the event
|
|
* @since 1.5
|
|
*/
|
|
public void mouseExited(MouseEvent e) {
|
|
if (!isDragging) {
|
|
setThumbRollover(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Listener for cursor keys.
|
|
*/
|
|
protected class ArrowButtonListener extends MouseAdapter
|
|
{
|
|
// Because we are handling both mousePressed and Actions
|
|
// we need to make sure we don't fire under both conditions.
|
|
// (keyfocus on scrollbars causes action without mousePress
|
|
boolean handledEvent;
|
|
|
|
public void mousePressed(MouseEvent e) {
|
|
if(!scrollbar.isEnabled()) { return; }
|
|
// not an unmodified left mouse button
|
|
//if(e.getModifiers() != InputEvent.BUTTON1_MASK) {return; }
|
|
if( ! SwingUtilities.isLeftMouseButton(e)) { return; }
|
|
|
|
int direction = (e.getSource() == incrButton) ? 1 : -1;
|
|
|
|
scrollByUnit(direction);
|
|
scrollTimer.stop();
|
|
scrollListener.setDirection(direction);
|
|
scrollListener.setScrollByBlock(false);
|
|
scrollTimer.start();
|
|
|
|
handledEvent = true;
|
|
if (!scrollbar.hasFocus() && scrollbar.isRequestFocusEnabled()) {
|
|
scrollbar.requestFocus();
|
|
}
|
|
}
|
|
|
|
public void mouseReleased(MouseEvent e) {
|
|
scrollTimer.stop();
|
|
handledEvent = false;
|
|
scrollbar.setValueIsAdjusting(false);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Listener for scrolling events initiated in the
|
|
* <code>ScrollPane</code>.
|
|
*/
|
|
protected class ScrollListener implements ActionListener
|
|
{
|
|
int direction = +1;
|
|
boolean useBlockIncrement;
|
|
|
|
public ScrollListener() {
|
|
direction = +1;
|
|
useBlockIncrement = false;
|
|
}
|
|
|
|
public ScrollListener(int dir, boolean block) {
|
|
direction = dir;
|
|
useBlockIncrement = block;
|
|
}
|
|
|
|
public void setDirection(int direction) { this.direction = direction; }
|
|
public void setScrollByBlock(boolean block) { this.useBlockIncrement = block; }
|
|
|
|
public void actionPerformed(ActionEvent e) {
|
|
if(useBlockIncrement) {
|
|
scrollByBlock(direction);
|
|
// Stop scrolling if the thumb catches up with the mouse
|
|
if(scrollbar.getOrientation() == JScrollBar.VERTICAL) {
|
|
if(direction > 0) {
|
|
if(getThumbBounds().y + getThumbBounds().height
|
|
>= trackListener.currentMouseY)
|
|
((Timer)e.getSource()).stop();
|
|
} else if(getThumbBounds().y <= trackListener.currentMouseY) {
|
|
((Timer)e.getSource()).stop();
|
|
}
|
|
} else {
|
|
if ((direction > 0 && !isMouseAfterThumb())
|
|
|| (direction < 0 && !isMouseBeforeThumb())) {
|
|
|
|
((Timer)e.getSource()).stop();
|
|
}
|
|
}
|
|
} else {
|
|
scrollByUnit(direction);
|
|
}
|
|
|
|
if(direction > 0
|
|
&& scrollbar.getValue()+scrollbar.getVisibleAmount()
|
|
>= scrollbar.getMaximum())
|
|
((Timer)e.getSource()).stop();
|
|
else if(direction < 0
|
|
&& scrollbar.getValue() <= scrollbar.getMinimum())
|
|
((Timer)e.getSource()).stop();
|
|
}
|
|
}
|
|
|
|
private boolean isMouseLeftOfThumb() {
|
|
return trackListener.currentMouseX < getThumbBounds().x;
|
|
}
|
|
|
|
private boolean isMouseRightOfThumb() {
|
|
Rectangle tb = getThumbBounds();
|
|
return trackListener.currentMouseX > tb.x + tb.width;
|
|
}
|
|
|
|
private boolean isMouseBeforeThumb() {
|
|
return scrollbar.getComponentOrientation().isLeftToRight()
|
|
? isMouseLeftOfThumb()
|
|
: isMouseRightOfThumb();
|
|
}
|
|
|
|
private boolean isMouseAfterThumb() {
|
|
return scrollbar.getComponentOrientation().isLeftToRight()
|
|
? isMouseRightOfThumb()
|
|
: isMouseLeftOfThumb();
|
|
}
|
|
|
|
private void updateButtonDirections() {
|
|
int orient = scrollbar.getOrientation();
|
|
if (scrollbar.getComponentOrientation().isLeftToRight()) {
|
|
if (incrButton instanceof BasicArrowButton) {
|
|
((BasicArrowButton)incrButton).setDirection(
|
|
orient == HORIZONTAL? EAST : SOUTH);
|
|
}
|
|
if (decrButton instanceof BasicArrowButton) {
|
|
((BasicArrowButton)decrButton).setDirection(
|
|
orient == HORIZONTAL? WEST : NORTH);
|
|
}
|
|
}
|
|
else {
|
|
if (incrButton instanceof BasicArrowButton) {
|
|
((BasicArrowButton)incrButton).setDirection(
|
|
orient == HORIZONTAL? WEST : SOUTH);
|
|
}
|
|
if (decrButton instanceof BasicArrowButton) {
|
|
((BasicArrowButton)decrButton).setDirection(
|
|
orient == HORIZONTAL ? EAST : NORTH);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class PropertyChangeHandler 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.
|
|
|
|
public void propertyChange(PropertyChangeEvent e) {
|
|
getHandler().propertyChange(e);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Used for scrolling the scrollbar.
|
|
*/
|
|
private static class Actions extends UIAction {
|
|
private static final String POSITIVE_UNIT_INCREMENT =
|
|
"positiveUnitIncrement";
|
|
private static final String POSITIVE_BLOCK_INCREMENT =
|
|
"positiveBlockIncrement";
|
|
private static final String NEGATIVE_UNIT_INCREMENT =
|
|
"negativeUnitIncrement";
|
|
private static final String NEGATIVE_BLOCK_INCREMENT =
|
|
"negativeBlockIncrement";
|
|
private static final String MIN_SCROLL = "minScroll";
|
|
private static final String MAX_SCROLL = "maxScroll";
|
|
|
|
Actions(String name) {
|
|
super(name);
|
|
}
|
|
|
|
public void actionPerformed(ActionEvent e) {
|
|
JScrollBar scrollBar = (JScrollBar)e.getSource();
|
|
String key = getName();
|
|
if (key == POSITIVE_UNIT_INCREMENT) {
|
|
scroll(scrollBar, POSITIVE_SCROLL, false);
|
|
}
|
|
else if (key == POSITIVE_BLOCK_INCREMENT) {
|
|
scroll(scrollBar, POSITIVE_SCROLL, true);
|
|
}
|
|
else if (key == NEGATIVE_UNIT_INCREMENT) {
|
|
scroll(scrollBar, NEGATIVE_SCROLL, false);
|
|
}
|
|
else if (key == NEGATIVE_BLOCK_INCREMENT) {
|
|
scroll(scrollBar, NEGATIVE_SCROLL, true);
|
|
}
|
|
else if (key == MIN_SCROLL) {
|
|
scroll(scrollBar, BasicScrollBarUI.MIN_SCROLL, true);
|
|
}
|
|
else if (key == MAX_SCROLL) {
|
|
scroll(scrollBar, BasicScrollBarUI.MAX_SCROLL, true);
|
|
}
|
|
}
|
|
private void scroll(JScrollBar scrollBar, int dir, boolean block) {
|
|
|
|
if (dir == NEGATIVE_SCROLL || dir == POSITIVE_SCROLL) {
|
|
int amount;
|
|
// Don't use the BasicScrollBarUI.scrollByXXX methods as we
|
|
// don't want to use an invokeLater to reset the trackHighlight
|
|
// via an invokeLater
|
|
if (block) {
|
|
if (dir == NEGATIVE_SCROLL) {
|
|
amount = -1 * scrollBar.getBlockIncrement(-1);
|
|
}
|
|
else {
|
|
amount = scrollBar.getBlockIncrement(1);
|
|
}
|
|
}
|
|
else {
|
|
if (dir == NEGATIVE_SCROLL) {
|
|
amount = -1 * scrollBar.getUnitIncrement(-1);
|
|
}
|
|
else {
|
|
amount = scrollBar.getUnitIncrement(1);
|
|
}
|
|
}
|
|
scrollBar.setValue(scrollBar.getValue() + amount);
|
|
}
|
|
else if (dir == BasicScrollBarUI.MIN_SCROLL) {
|
|
scrollBar.setValue(scrollBar.getMinimum());
|
|
}
|
|
else if (dir == BasicScrollBarUI.MAX_SCROLL) {
|
|
scrollBar.setValue(scrollBar.getMaximum());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// EventHandler
|
|
//
|
|
private class Handler implements FocusListener, PropertyChangeListener {
|
|
//
|
|
// FocusListener
|
|
//
|
|
public void focusGained(FocusEvent e) {
|
|
scrollbar.repaint();
|
|
}
|
|
|
|
public void focusLost(FocusEvent e) {
|
|
scrollbar.repaint();
|
|
}
|
|
|
|
|
|
//
|
|
// PropertyChangeListener
|
|
//
|
|
public void propertyChange(PropertyChangeEvent e) {
|
|
String propertyName = e.getPropertyName();
|
|
|
|
if ("model" == propertyName) {
|
|
BoundedRangeModel oldModel = (BoundedRangeModel)e.getOldValue();
|
|
BoundedRangeModel newModel = (BoundedRangeModel)e.getNewValue();
|
|
oldModel.removeChangeListener(modelListener);
|
|
newModel.addChangeListener(modelListener);
|
|
scrollBarValue = scrollbar.getValue();
|
|
scrollbar.repaint();
|
|
scrollbar.revalidate();
|
|
} else if ("orientation" == propertyName) {
|
|
updateButtonDirections();
|
|
} else if ("componentOrientation" == propertyName) {
|
|
updateButtonDirections();
|
|
InputMap inputMap = getInputMap(JComponent.WHEN_FOCUSED);
|
|
SwingUtilities.replaceUIInputMap(scrollbar, JComponent.WHEN_FOCUSED, inputMap);
|
|
}
|
|
}
|
|
}
|
|
}
|