mirror of git://gcc.gnu.org/git/gcc.git
1514 lines
43 KiB
Java
1514 lines
43 KiB
Java
/* BasicScrollBarUI.java --
|
|
Copyright (C) 2004, 2005, 2006, Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU Classpath 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 for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301 USA.
|
|
|
|
Linking this library statically or dynamically with other modules is
|
|
making a combined work based on this library. Thus, the terms and
|
|
conditions of the GNU General Public License cover the whole
|
|
combination.
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
permission to link this library with independent modules to produce an
|
|
executable, regardless of the license terms of these independent
|
|
modules, and to copy and distribute the resulting executable under
|
|
terms of your choice, provided that you also meet, for each linked
|
|
independent module, the terms and conditions of the license of that
|
|
module. An independent module is a module which is not derived from
|
|
or based on this library. If you modify this library, you may extend
|
|
this exception to your version of the library, but you are not
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
exception statement from your version. */
|
|
|
|
|
|
package javax.swing.plaf.basic;
|
|
|
|
import java.awt.Color;
|
|
import java.awt.Component;
|
|
import java.awt.Container;
|
|
import java.awt.Dimension;
|
|
import java.awt.Graphics;
|
|
import java.awt.Insets;
|
|
import java.awt.LayoutManager;
|
|
import java.awt.Rectangle;
|
|
import java.awt.event.ActionEvent;
|
|
import java.awt.event.ActionListener;
|
|
import java.awt.event.MouseAdapter;
|
|
import java.awt.event.MouseEvent;
|
|
import java.awt.event.MouseMotionListener;
|
|
import java.beans.PropertyChangeEvent;
|
|
import java.beans.PropertyChangeListener;
|
|
|
|
import javax.swing.AbstractAction;
|
|
import javax.swing.ActionMap;
|
|
import javax.swing.BoundedRangeModel;
|
|
import javax.swing.InputMap;
|
|
import javax.swing.JButton;
|
|
import javax.swing.JComponent;
|
|
import javax.swing.JScrollBar;
|
|
import javax.swing.JSlider;
|
|
import javax.swing.LookAndFeel;
|
|
import javax.swing.SwingConstants;
|
|
import javax.swing.SwingUtilities;
|
|
import javax.swing.Timer;
|
|
import javax.swing.UIManager;
|
|
import javax.swing.event.ChangeEvent;
|
|
import javax.swing.event.ChangeListener;
|
|
import javax.swing.plaf.ActionMapUIResource;
|
|
import javax.swing.plaf.ComponentUI;
|
|
import javax.swing.plaf.ScrollBarUI;
|
|
|
|
/**
|
|
* The Basic Look and Feel UI delegate for JScrollBar.
|
|
*/
|
|
public class BasicScrollBarUI extends ScrollBarUI implements LayoutManager,
|
|
SwingConstants
|
|
{
|
|
/**
|
|
* A helper class that listens to the two JButtons on each end of the
|
|
* JScrollBar.
|
|
*/
|
|
protected class ArrowButtonListener extends MouseAdapter
|
|
{
|
|
|
|
/**
|
|
* Move the thumb in the direction specified by the button's arrow. If
|
|
* this button is held down, then it should keep moving the thumb.
|
|
*
|
|
* @param e The MouseEvent fired by the JButton.
|
|
*/
|
|
public void mousePressed(MouseEvent e)
|
|
{
|
|
scrollTimer.stop();
|
|
scrollListener.setScrollByBlock(false);
|
|
if (e.getSource() == incrButton)
|
|
scrollListener.setDirection(POSITIVE_SCROLL);
|
|
else if (e.getSource() == decrButton)
|
|
scrollListener.setDirection(NEGATIVE_SCROLL);
|
|
scrollTimer.setDelay(100);
|
|
scrollTimer.start();
|
|
}
|
|
|
|
/**
|
|
* Stops the thumb when the JButton is released.
|
|
*
|
|
* @param e The MouseEvent fired by the JButton.
|
|
*/
|
|
public void mouseReleased(MouseEvent e)
|
|
{
|
|
scrollTimer.stop();
|
|
scrollTimer.setDelay(300);
|
|
if (e.getSource() == incrButton)
|
|
scrollByUnit(POSITIVE_SCROLL);
|
|
else if (e.getSource() == decrButton)
|
|
scrollByUnit(NEGATIVE_SCROLL);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A helper class that listens to the ScrollBar's model for ChangeEvents.
|
|
*/
|
|
protected class ModelListener implements ChangeListener
|
|
{
|
|
/**
|
|
* Called when the model changes.
|
|
*
|
|
* @param e The ChangeEvent fired by the model.
|
|
*/
|
|
public void stateChanged(ChangeEvent e)
|
|
{
|
|
calculatePreferredSize();
|
|
updateThumbRect();
|
|
scrollbar.repaint();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A helper class that listens to the ScrollBar's properties.
|
|
*/
|
|
public class PropertyChangeHandler implements PropertyChangeListener
|
|
{
|
|
/**
|
|
* Called when one of the ScrollBar's properties change.
|
|
*
|
|
* @param e The PropertyChangeEvent fired by the ScrollBar.
|
|
*/
|
|
public void propertyChange(PropertyChangeEvent e)
|
|
{
|
|
if (e.getPropertyName().equals("model"))
|
|
{
|
|
((BoundedRangeModel) e.getOldValue()).removeChangeListener(modelListener);
|
|
scrollbar.getModel().addChangeListener(modelListener);
|
|
updateThumbRect();
|
|
}
|
|
else if (e.getPropertyName().equals("orientation"))
|
|
{
|
|
uninstallListeners();
|
|
uninstallComponents();
|
|
uninstallDefaults();
|
|
installDefaults();
|
|
installComponents();
|
|
installListeners();
|
|
}
|
|
else if (e.getPropertyName().equals("enabled"))
|
|
{
|
|
Boolean b = (Boolean) e.getNewValue();
|
|
if (incrButton != null)
|
|
incrButton.setEnabled(b.booleanValue());
|
|
if (decrButton != null)
|
|
decrButton.setEnabled(b.booleanValue());
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A helper class that listens for events from the timer that is used to
|
|
* move the thumb.
|
|
*/
|
|
protected class ScrollListener implements ActionListener
|
|
{
|
|
/** The direction the thumb moves in. */
|
|
private transient int direction;
|
|
|
|
/** Whether movement will be in blocks. */
|
|
private transient boolean block;
|
|
|
|
/**
|
|
* Creates a new ScrollListener object. The default is scrolling
|
|
* positively with block movement.
|
|
*/
|
|
public ScrollListener()
|
|
{
|
|
direction = POSITIVE_SCROLL;
|
|
block = true;
|
|
}
|
|
|
|
/**
|
|
* Creates a new ScrollListener object using the given direction and
|
|
* block.
|
|
*
|
|
* @param dir The direction to move in.
|
|
* @param block Whether movement will be in blocks.
|
|
*/
|
|
public ScrollListener(int dir, boolean block)
|
|
{
|
|
direction = dir;
|
|
this.block = block;
|
|
}
|
|
|
|
/**
|
|
* Sets the direction to scroll in.
|
|
*
|
|
* @param direction The direction to scroll in.
|
|
*/
|
|
public void setDirection(int direction)
|
|
{
|
|
this.direction = direction;
|
|
}
|
|
|
|
/**
|
|
* Sets whether scrolling will be done in blocks.
|
|
*
|
|
* @param block Whether scrolling will be in blocks.
|
|
*/
|
|
public void setScrollByBlock(boolean block)
|
|
{
|
|
this.block = block;
|
|
}
|
|
|
|
/**
|
|
* Called every time the timer reaches its interval.
|
|
*
|
|
* @param e The ActionEvent fired by the timer.
|
|
*/
|
|
public void actionPerformed(ActionEvent e)
|
|
{
|
|
if (block)
|
|
{
|
|
// Only need to check it if it's block scrolling
|
|
// We only block scroll if the click occurs
|
|
// in the track.
|
|
if (!trackListener.shouldScroll(direction))
|
|
{
|
|
trackHighlight = NO_HIGHLIGHT;
|
|
scrollbar.repaint();
|
|
return;
|
|
}
|
|
scrollByBlock(direction);
|
|
}
|
|
else
|
|
scrollByUnit(direction);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Helper class that listens for movement on the track.
|
|
*/
|
|
protected class TrackListener extends MouseAdapter
|
|
implements MouseMotionListener
|
|
{
|
|
/** The current X coordinate of the mouse. */
|
|
protected int currentMouseX;
|
|
|
|
/** The current Y coordinate of the mouse. */
|
|
protected int currentMouseY;
|
|
|
|
/**
|
|
* The offset between the current mouse cursor and the current value of
|
|
* the scrollbar.
|
|
*/
|
|
protected int offset;
|
|
|
|
/**
|
|
* This method is called when the mouse is being dragged.
|
|
*
|
|
* @param e The MouseEvent given.
|
|
*/
|
|
public void mouseDragged(MouseEvent e)
|
|
{
|
|
currentMouseX = e.getX();
|
|
currentMouseY = e.getY();
|
|
if (scrollbar.getValueIsAdjusting())
|
|
{
|
|
int value;
|
|
if (scrollbar.getOrientation() == SwingConstants.HORIZONTAL)
|
|
value = valueForXPosition(currentMouseX) - offset;
|
|
else
|
|
value = valueForYPosition(currentMouseY) - offset;
|
|
|
|
scrollbar.setValue(value);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method is called when the mouse is moved.
|
|
*
|
|
* @param e The MouseEvent given.
|
|
*/
|
|
public void mouseMoved(MouseEvent e)
|
|
{
|
|
if (thumbRect.contains(e.getPoint()))
|
|
thumbRollover = true;
|
|
else
|
|
thumbRollover = false;
|
|
}
|
|
|
|
/**
|
|
* This method is called when the mouse is pressed. When it is pressed,
|
|
* the thumb should move in blocks towards the cursor.
|
|
*
|
|
* @param e The MouseEvent given.
|
|
*/
|
|
public void mousePressed(MouseEvent e)
|
|
{
|
|
currentMouseX = e.getX();
|
|
currentMouseY = e.getY();
|
|
|
|
int value;
|
|
if (scrollbar.getOrientation() == SwingConstants.HORIZONTAL)
|
|
value = valueForXPosition(currentMouseX);
|
|
else
|
|
value = valueForYPosition(currentMouseY);
|
|
|
|
if (! thumbRect.contains(e.getPoint()))
|
|
{
|
|
scrollTimer.stop();
|
|
scrollListener.setScrollByBlock(true);
|
|
if (value > scrollbar.getValue())
|
|
{
|
|
trackHighlight = INCREASE_HIGHLIGHT;
|
|
scrollListener.setDirection(POSITIVE_SCROLL);
|
|
}
|
|
else
|
|
{
|
|
trackHighlight = DECREASE_HIGHLIGHT;
|
|
scrollListener.setDirection(NEGATIVE_SCROLL);
|
|
}
|
|
scrollTimer.setDelay(100);
|
|
scrollTimer.start();
|
|
}
|
|
else
|
|
{
|
|
// We'd like to keep track of where the cursor
|
|
// is inside the thumb.
|
|
// This works because the scrollbar's value represents
|
|
// "lower" edge of the thumb. The value at which
|
|
// the cursor is at must be greater or equal
|
|
// to that value.
|
|
|
|
scrollListener.setScrollByBlock(false);
|
|
scrollbar.setValueIsAdjusting(true);
|
|
offset = value - scrollbar.getValue();
|
|
}
|
|
scrollbar.repaint();
|
|
}
|
|
|
|
/**
|
|
* This method is called when the mouse is released. It should stop
|
|
* movement on the thumb
|
|
*
|
|
* @param e The MouseEvent given.
|
|
*/
|
|
public void mouseReleased(MouseEvent e)
|
|
{
|
|
scrollTimer.stop();
|
|
scrollTimer.setDelay(300);
|
|
currentMouseX = e.getX();
|
|
currentMouseY = e.getY();
|
|
|
|
if (shouldScroll(POSITIVE_SCROLL))
|
|
scrollByBlock(POSITIVE_SCROLL);
|
|
else if (shouldScroll(NEGATIVE_SCROLL))
|
|
scrollByBlock(NEGATIVE_SCROLL);
|
|
|
|
trackHighlight = NO_HIGHLIGHT;
|
|
scrollListener.setScrollByBlock(false);
|
|
scrollbar.setValueIsAdjusting(true);
|
|
scrollbar.repaint();
|
|
}
|
|
|
|
/**
|
|
* A helper method that decides whether we should keep scrolling in the
|
|
* given direction.
|
|
*
|
|
* @param direction The direction to check for.
|
|
*
|
|
* @return Whether the thumb should keep scrolling.
|
|
*/
|
|
boolean shouldScroll(int direction)
|
|
{
|
|
int value;
|
|
if (scrollbar.getOrientation() == HORIZONTAL)
|
|
value = valueForXPosition(currentMouseX);
|
|
else
|
|
value = valueForYPosition(currentMouseY);
|
|
|
|
if (thumbRect.contains(currentMouseX, currentMouseY))
|
|
return false;
|
|
|
|
if (direction == POSITIVE_SCROLL)
|
|
return value > scrollbar.getValue();
|
|
else
|
|
return value < scrollbar.getValue();
|
|
}
|
|
}
|
|
|
|
/** The listener that listens to the JButtons. */
|
|
protected ArrowButtonListener buttonListener;
|
|
|
|
/** The listener that listens to the model. */
|
|
protected ModelListener modelListener;
|
|
|
|
/** The listener that listens to the scrollbar for property changes. */
|
|
protected PropertyChangeListener propertyChangeListener;
|
|
|
|
/** The listener that listens to the timer. */
|
|
protected ScrollListener scrollListener;
|
|
|
|
/** The listener that listens for MouseEvents on the track. */
|
|
protected TrackListener trackListener;
|
|
|
|
/** The JButton that decrements the scrollbar's value. */
|
|
protected JButton decrButton;
|
|
|
|
/** The JButton that increments the scrollbar's value. */
|
|
protected JButton incrButton;
|
|
|
|
/** The dimensions of the maximum thumb size. */
|
|
protected Dimension maximumThumbSize;
|
|
|
|
/** The dimensions of the minimum thumb size. */
|
|
protected Dimension minimumThumbSize;
|
|
|
|
/** The color of the thumb. */
|
|
protected Color thumbColor;
|
|
|
|
/** The outer shadow of the thumb. */
|
|
protected Color thumbDarkShadowColor;
|
|
|
|
/** The top and left edge color for the thumb. */
|
|
protected Color thumbHighlightColor;
|
|
|
|
/** The outer light shadow for the thumb. */
|
|
protected Color thumbLightShadowColor;
|
|
|
|
/** The color that is used when the mouse press occurs in the track. */
|
|
protected Color trackHighlightColor;
|
|
|
|
/** The color of the track. */
|
|
protected Color trackColor;
|
|
|
|
/** The size and position of the track. */
|
|
protected Rectangle trackRect;
|
|
|
|
/** The size and position of the thumb. */
|
|
protected Rectangle thumbRect;
|
|
|
|
/** Indicates that the decrease highlight should be painted. */
|
|
protected static final int DECREASE_HIGHLIGHT = 1;
|
|
|
|
/** Indicates that the increase highlight should be painted. */
|
|
protected static final int INCREASE_HIGHLIGHT = 2;
|
|
|
|
/** Indicates that no highlight should be painted. */
|
|
protected static final int NO_HIGHLIGHT = 0;
|
|
|
|
/** Indicates that the scrolling direction is positive. */
|
|
private static final int POSITIVE_SCROLL = 1;
|
|
|
|
/** Indicates that the scrolling direction is negative. */
|
|
private static final int NEGATIVE_SCROLL = -1;
|
|
|
|
/** The cached preferred size for the scrollbar. */
|
|
private transient Dimension preferredSize;
|
|
|
|
/** The current highlight status. */
|
|
protected int trackHighlight;
|
|
|
|
/** FIXME: Use this for something (presumably mouseDragged) */
|
|
protected boolean isDragging;
|
|
|
|
/** The timer used to move the thumb when the mouse is held. */
|
|
protected Timer scrollTimer;
|
|
|
|
/** The scrollbar this UI is acting for. */
|
|
protected JScrollBar scrollbar;
|
|
|
|
/** True if the mouse is over the thumb. */
|
|
boolean thumbRollover;
|
|
|
|
/**
|
|
* This method adds a component to the layout.
|
|
*
|
|
* @param name The name to associate with the component that is added.
|
|
* @param child The Component to add.
|
|
*/
|
|
public void addLayoutComponent(String name, Component child)
|
|
{
|
|
// You should not be adding stuff to this component.
|
|
// The contents are fixed.
|
|
}
|
|
|
|
/**
|
|
* This method configures the scrollbar's colors. This can be done by
|
|
* looking up the standard colors from the Look and Feel defaults.
|
|
*/
|
|
protected void configureScrollBarColors()
|
|
{
|
|
trackColor = UIManager.getColor("ScrollBar.track");
|
|
trackHighlightColor = UIManager.getColor("ScrollBar.trackHighlight");
|
|
thumbColor = UIManager.getColor("ScrollBar.thumb");
|
|
thumbHighlightColor = UIManager.getColor("ScrollBar.thumbHighlight");
|
|
thumbDarkShadowColor = UIManager.getColor("ScrollBar.thumbDarkShadow");
|
|
thumbLightShadowColor = UIManager.getColor("ScrollBar.thumbShadow");
|
|
}
|
|
|
|
/**
|
|
* This method creates an ArrowButtonListener.
|
|
*
|
|
* @return A new ArrowButtonListener.
|
|
*/
|
|
protected ArrowButtonListener createArrowButtonListener()
|
|
{
|
|
return new ArrowButtonListener();
|
|
}
|
|
|
|
/**
|
|
* This method creates a new JButton with the appropriate icon for the
|
|
* orientation.
|
|
*
|
|
* @param orientation The orientation this JButton uses.
|
|
*
|
|
* @return The increase JButton.
|
|
*/
|
|
protected JButton createIncreaseButton(int orientation)
|
|
{
|
|
return new BasicArrowButton(orientation);
|
|
}
|
|
|
|
/**
|
|
* This method creates a new JButton with the appropriate icon for the
|
|
* orientation.
|
|
*
|
|
* @param orientation The orientation this JButton uses.
|
|
*
|
|
* @return The decrease JButton.
|
|
*/
|
|
protected JButton createDecreaseButton(int orientation)
|
|
{
|
|
return new BasicArrowButton(orientation);
|
|
}
|
|
|
|
/**
|
|
* This method creates a new ModelListener.
|
|
*
|
|
* @return A new ModelListener.
|
|
*/
|
|
protected ModelListener createModelListener()
|
|
{
|
|
return new ModelListener();
|
|
}
|
|
|
|
/**
|
|
* This method creates a new PropertyChangeListener.
|
|
*
|
|
* @return A new PropertyChangeListener.
|
|
*/
|
|
protected PropertyChangeListener createPropertyChangeListener()
|
|
{
|
|
return new PropertyChangeHandler();
|
|
}
|
|
|
|
/**
|
|
* This method creates a new ScrollListener.
|
|
*
|
|
* @return A new ScrollListener.
|
|
*/
|
|
protected ScrollListener createScrollListener()
|
|
{
|
|
return new ScrollListener();
|
|
}
|
|
|
|
/**
|
|
* This method creates a new TrackListener.
|
|
*
|
|
* @return A new TrackListener.
|
|
*/
|
|
protected TrackListener createTrackListener()
|
|
{
|
|
return new TrackListener();
|
|
}
|
|
|
|
/**
|
|
* This method returns a new BasicScrollBarUI.
|
|
*
|
|
* @param c The JComponent to create a UI for.
|
|
*
|
|
* @return A new BasicScrollBarUI.
|
|
*/
|
|
public static ComponentUI createUI(JComponent c)
|
|
{
|
|
return new BasicScrollBarUI();
|
|
}
|
|
|
|
/**
|
|
* This method returns the maximum size for this JComponent.
|
|
*
|
|
* @param c The JComponent to measure the maximum size for.
|
|
*
|
|
* @return The maximum size for the component.
|
|
*/
|
|
public Dimension getMaximumSize(JComponent c)
|
|
{
|
|
return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
|
|
}
|
|
|
|
/**
|
|
* This method returns the maximum thumb size.
|
|
*
|
|
* @return The maximum thumb size.
|
|
*/
|
|
protected Dimension getMaximumThumbSize()
|
|
{
|
|
return maximumThumbSize;
|
|
}
|
|
|
|
/**
|
|
* This method returns the minimum size for this JComponent.
|
|
*
|
|
* @param c The JComponent to measure the minimum size for.
|
|
*
|
|
* @return The minimum size for the component.
|
|
*/
|
|
public Dimension getMinimumSize(JComponent c)
|
|
{
|
|
return getPreferredSize(c);
|
|
}
|
|
|
|
/**
|
|
* This method returns the minimum thumb size.
|
|
*
|
|
* @return The minimum thumb size.
|
|
*/
|
|
protected Dimension getMinimumThumbSize()
|
|
{
|
|
return minimumThumbSize;
|
|
}
|
|
|
|
/**
|
|
* This method calculates the preferred size since calling
|
|
* getPreferredSize() returns a cached value.
|
|
* This is package-private to avoid an accessor method.
|
|
*/
|
|
void calculatePreferredSize()
|
|
{
|
|
int height;
|
|
int width;
|
|
height = width = 0;
|
|
|
|
if (scrollbar.getOrientation() == SwingConstants.HORIZONTAL)
|
|
{
|
|
width += incrButton.getPreferredSize().getWidth();
|
|
width += decrButton.getPreferredSize().getWidth();
|
|
width += 16;
|
|
height = UIManager.getInt("ScrollBar.width");
|
|
}
|
|
else
|
|
{
|
|
height += incrButton.getPreferredSize().getHeight();
|
|
height += decrButton.getPreferredSize().getHeight();
|
|
height += 16;
|
|
width = UIManager.getInt("ScrollBar.width");
|
|
}
|
|
|
|
Insets insets = scrollbar.getInsets();
|
|
|
|
height += insets.top + insets.bottom;
|
|
width += insets.left + insets.right;
|
|
|
|
preferredSize = new Dimension(width, height);
|
|
}
|
|
|
|
/**
|
|
* This method returns a cached value of the preferredSize. The only
|
|
* restrictions are: If the scrollbar is horizontal, the height should be
|
|
* the maximum of the height of the JButtons and the minimum width of the
|
|
* thumb. For vertical scrollbars, the calculation is similar (swap width
|
|
* for height and vice versa).
|
|
*
|
|
* @param c The JComponent to measure.
|
|
*
|
|
* @return The preferredSize.
|
|
*/
|
|
public Dimension getPreferredSize(JComponent c)
|
|
{
|
|
calculatePreferredSize();
|
|
return preferredSize;
|
|
}
|
|
|
|
/**
|
|
* This method returns the thumb's bounds based on the current value of the
|
|
* scrollbar. This method updates the cached value and returns that.
|
|
*
|
|
* @return The thumb bounds.
|
|
*/
|
|
protected Rectangle getThumbBounds()
|
|
{
|
|
return thumbRect;
|
|
}
|
|
|
|
/**
|
|
* This method calculates the bounds of the track. This method updates the
|
|
* cached value and returns it.
|
|
*
|
|
* @return The track's bounds.
|
|
*/
|
|
protected Rectangle getTrackBounds()
|
|
{
|
|
return trackRect;
|
|
}
|
|
|
|
/**
|
|
* This method installs any addition Components that are a part of or
|
|
* related to this scrollbar.
|
|
*/
|
|
protected void installComponents()
|
|
{
|
|
int orientation = scrollbar.getOrientation();
|
|
switch (orientation)
|
|
{
|
|
case JScrollBar.HORIZONTAL:
|
|
incrButton = createIncreaseButton(EAST);
|
|
decrButton = createDecreaseButton(WEST);
|
|
break;
|
|
default:
|
|
incrButton = createIncreaseButton(SOUTH);
|
|
decrButton = createDecreaseButton(NORTH);
|
|
break;
|
|
}
|
|
|
|
if (incrButton != null)
|
|
scrollbar.add(incrButton);
|
|
if (decrButton != null)
|
|
scrollbar.add(decrButton);
|
|
}
|
|
|
|
/**
|
|
* This method installs the defaults for the scrollbar specified by the
|
|
* Basic Look and Feel.
|
|
*/
|
|
protected void installDefaults()
|
|
{
|
|
LookAndFeel.installColors(scrollbar, "ScrollBar.background",
|
|
"ScrollBar.foreground");
|
|
LookAndFeel.installBorder(scrollbar, "ScrollBar.border");
|
|
scrollbar.setOpaque(true);
|
|
scrollbar.setLayout(this);
|
|
|
|
configureScrollBarColors();
|
|
|
|
maximumThumbSize = UIManager.getDimension("ScrollBar.maximumThumbSize");
|
|
minimumThumbSize = UIManager.getDimension("ScrollBar.minimumThumbSize");
|
|
}
|
|
|
|
/**
|
|
* Installs the input map from the look and feel defaults, and a
|
|
* corresponding action map. Note the the keyboard bindings will only
|
|
* work when the {@link JScrollBar} component has the focus, which is rare.
|
|
*/
|
|
protected void installKeyboardActions()
|
|
{
|
|
InputMap keyMap = getInputMap(
|
|
JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
|
|
SwingUtilities.replaceUIInputMap(scrollbar,
|
|
JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, keyMap);
|
|
ActionMap map = getActionMap();
|
|
SwingUtilities.replaceUIActionMap(scrollbar, map);
|
|
}
|
|
|
|
/**
|
|
* Uninstalls the input map and action map installed by
|
|
* {@link #installKeyboardActions()}.
|
|
*/
|
|
protected void uninstallKeyboardActions()
|
|
{
|
|
SwingUtilities.replaceUIActionMap(scrollbar, null);
|
|
SwingUtilities.replaceUIInputMap(scrollbar,
|
|
JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, null);
|
|
}
|
|
|
|
InputMap getInputMap(int condition)
|
|
{
|
|
if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT)
|
|
return (InputMap) UIManager.get("ScrollBar.focusInputMap");
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Returns the action map for the {@link JScrollBar}. All scroll bars
|
|
* share a single action map which is created the first time this method is
|
|
* called, then stored in the UIDefaults table for subsequent access.
|
|
*
|
|
* @return The shared action map.
|
|
*/
|
|
ActionMap getActionMap()
|
|
{
|
|
ActionMap map = (ActionMap) UIManager.get("ScrollBar.actionMap");
|
|
|
|
if (map == null) // first time here
|
|
{
|
|
map = createActionMap();
|
|
if (map != null)
|
|
UIManager.put("ScrollBar.actionMap", map);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
/**
|
|
* Creates the action map shared by all {@link JSlider} instances.
|
|
* This method is called once by {@link #getActionMap()} when it
|
|
* finds no action map in the UIDefaults table...after the map is
|
|
* created, it gets added to the defaults table so that subsequent
|
|
* calls to {@link #getActionMap()} will return the same shared
|
|
* instance.
|
|
*
|
|
* @return The action map.
|
|
*/
|
|
ActionMap createActionMap()
|
|
{
|
|
ActionMap map = new ActionMapUIResource();
|
|
map.put("positiveUnitIncrement",
|
|
new AbstractAction("positiveUnitIncrement") {
|
|
public void actionPerformed(ActionEvent event)
|
|
{
|
|
JScrollBar sb = (JScrollBar) event.getSource();
|
|
if (sb.isVisible())
|
|
{
|
|
int delta = sb.getUnitIncrement(1);
|
|
sb.setValue(sb.getValue() + delta);
|
|
}
|
|
}
|
|
}
|
|
);
|
|
map.put("positiveBlockIncrement",
|
|
new AbstractAction("positiveBlockIncrement") {
|
|
public void actionPerformed(ActionEvent event)
|
|
{
|
|
JScrollBar sb = (JScrollBar) event.getSource();
|
|
if (sb.isVisible())
|
|
{
|
|
int delta = sb.getBlockIncrement(1);
|
|
sb.setValue(sb.getValue() + delta);
|
|
}
|
|
}
|
|
}
|
|
);
|
|
map.put("negativeUnitIncrement",
|
|
new AbstractAction("negativeUnitIncrement") {
|
|
public void actionPerformed(ActionEvent event)
|
|
{
|
|
JScrollBar sb = (JScrollBar) event.getSource();
|
|
if (sb.isVisible())
|
|
{
|
|
int delta = sb.getUnitIncrement(-1);
|
|
sb.setValue(sb.getValue() + delta);
|
|
}
|
|
}
|
|
}
|
|
);
|
|
map.put("negativeBlockIncrement",
|
|
new AbstractAction("negativeBlockIncrement") {
|
|
public void actionPerformed(ActionEvent event)
|
|
{
|
|
JScrollBar sb = (JScrollBar) event.getSource();
|
|
if (sb.isVisible())
|
|
{
|
|
int delta = sb.getBlockIncrement(-1);
|
|
sb.setValue(sb.getValue() + delta);
|
|
}
|
|
}
|
|
}
|
|
);
|
|
map.put("minScroll",
|
|
new AbstractAction("minScroll") {
|
|
public void actionPerformed(ActionEvent event)
|
|
{
|
|
JScrollBar sb = (JScrollBar) event.getSource();
|
|
if (sb.isVisible())
|
|
{
|
|
sb.setValue(sb.getMinimum());
|
|
}
|
|
}
|
|
}
|
|
);
|
|
map.put("maxScroll",
|
|
new AbstractAction("maxScroll") {
|
|
public void actionPerformed(ActionEvent event)
|
|
{
|
|
JScrollBar sb = (JScrollBar) event.getSource();
|
|
if (sb.isVisible())
|
|
{
|
|
sb.setValue(sb.getMaximum());
|
|
}
|
|
}
|
|
}
|
|
);
|
|
return map;
|
|
}
|
|
|
|
/**
|
|
* This method installs any listeners for the scrollbar. This method also
|
|
* installs listeners for things such as the JButtons and the timer.
|
|
*/
|
|
protected void installListeners()
|
|
{
|
|
scrollListener = createScrollListener();
|
|
trackListener = createTrackListener();
|
|
buttonListener = createArrowButtonListener();
|
|
modelListener = createModelListener();
|
|
propertyChangeListener = createPropertyChangeListener();
|
|
|
|
scrollbar.addMouseMotionListener(trackListener);
|
|
scrollbar.addMouseListener(trackListener);
|
|
|
|
incrButton.addMouseListener(buttonListener);
|
|
decrButton.addMouseListener(buttonListener);
|
|
|
|
scrollbar.addPropertyChangeListener(propertyChangeListener);
|
|
scrollbar.getModel().addChangeListener(modelListener);
|
|
|
|
scrollTimer.addActionListener(scrollListener);
|
|
}
|
|
|
|
/**
|
|
* This method installs the UI for the component. This can include setting
|
|
* up listeners, defaults, and components. This also includes initializing
|
|
* any data objects.
|
|
*
|
|
* @param c The JComponent to install.
|
|
*/
|
|
public void installUI(JComponent c)
|
|
{
|
|
super.installUI(c);
|
|
if (c instanceof JScrollBar)
|
|
{
|
|
scrollbar = (JScrollBar) c;
|
|
|
|
trackRect = new Rectangle();
|
|
thumbRect = new Rectangle();
|
|
|
|
scrollTimer = new Timer(300, null);
|
|
|
|
installDefaults();
|
|
installComponents();
|
|
configureScrollBarColors();
|
|
installListeners();
|
|
installKeyboardActions();
|
|
|
|
calculatePreferredSize();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method lays out the scrollbar.
|
|
*
|
|
* @param scrollbarContainer The Container to layout.
|
|
*/
|
|
public void layoutContainer(Container scrollbarContainer)
|
|
{
|
|
if (scrollbarContainer instanceof JScrollBar)
|
|
{
|
|
if (scrollbar.getOrientation() == SwingConstants.HORIZONTAL)
|
|
layoutHScrollbar((JScrollBar) scrollbarContainer);
|
|
else
|
|
layoutVScrollbar((JScrollBar) scrollbarContainer);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method lays out the scrollbar horizontally.
|
|
*
|
|
* @param sb The JScrollBar to layout.
|
|
*/
|
|
protected void layoutHScrollbar(JScrollBar sb)
|
|
{
|
|
Rectangle vr = new Rectangle();
|
|
SwingUtilities.calculateInnerArea(scrollbar, vr);
|
|
|
|
Dimension incrDims = incrButton.getPreferredSize();
|
|
Dimension decrDims = decrButton.getPreferredSize();
|
|
|
|
// calculate and update the track bounds
|
|
SwingUtilities.calculateInnerArea(scrollbar, trackRect);
|
|
trackRect.width -= incrDims.getWidth();
|
|
trackRect.width -= decrDims.getWidth();
|
|
trackRect.x += decrDims.getWidth();
|
|
|
|
updateThumbRect();
|
|
|
|
decrButton.setBounds(vr.x, vr.y, decrDims.width, trackRect.height);
|
|
incrButton.setBounds(trackRect.x + trackRect.width, vr.y, incrDims.width,
|
|
trackRect.height);
|
|
}
|
|
|
|
/**
|
|
* This method lays out the scrollbar vertically.
|
|
*
|
|
* @param sb The JScrollBar to layout.
|
|
*/
|
|
protected void layoutVScrollbar(JScrollBar sb)
|
|
{
|
|
Rectangle vr = new Rectangle();
|
|
SwingUtilities.calculateInnerArea(scrollbar, vr);
|
|
|
|
Dimension incrDims = incrButton.getPreferredSize();
|
|
Dimension decrDims = decrButton.getPreferredSize();
|
|
|
|
// Update rectangles
|
|
SwingUtilities.calculateInnerArea(scrollbar, trackRect);
|
|
trackRect.height -= incrDims.getHeight();
|
|
trackRect.height -= decrDims.getHeight();
|
|
trackRect.y += decrDims.getHeight();
|
|
|
|
updateThumbRect();
|
|
|
|
decrButton.setBounds(vr.x, vr.y, trackRect.width, decrDims.height);
|
|
incrButton.setBounds(vr.x, trackRect.y + trackRect.height,
|
|
trackRect.width, incrDims.height);
|
|
}
|
|
|
|
/**
|
|
* Updates the thumb rect.
|
|
*/
|
|
void updateThumbRect()
|
|
{
|
|
int max = scrollbar.getMaximum();
|
|
int min = scrollbar.getMinimum();
|
|
int value = scrollbar.getValue();
|
|
int extent = scrollbar.getVisibleAmount();
|
|
if (max - extent <= min)
|
|
{
|
|
if (scrollbar.getOrientation() == JScrollBar.HORIZONTAL)
|
|
{
|
|
thumbRect.x = trackRect.x;
|
|
thumbRect.y = trackRect.y;
|
|
thumbRect.width = getMinimumThumbSize().width;
|
|
thumbRect.height = trackRect.height;
|
|
}
|
|
else
|
|
{
|
|
thumbRect.x = trackRect.x;
|
|
thumbRect.y = trackRect.y;
|
|
thumbRect.width = trackRect.width;
|
|
thumbRect.height = getMinimumThumbSize().height;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (scrollbar.getOrientation() == JScrollBar.HORIZONTAL)
|
|
{
|
|
thumbRect.x = trackRect.x;
|
|
thumbRect.width = Math.max(extent * trackRect.width / (max - min),
|
|
getMinimumThumbSize().width);
|
|
int availableWidth = trackRect.width - thumbRect.width;
|
|
thumbRect.x += (value - min) * availableWidth / (max - min - extent);
|
|
thumbRect.y = trackRect.y;
|
|
thumbRect.height = trackRect.height;
|
|
}
|
|
else
|
|
{
|
|
thumbRect.x = trackRect.x;
|
|
thumbRect.height = Math.max(extent * trackRect.height / (max - min),
|
|
getMinimumThumbSize().height);
|
|
int availableHeight = trackRect.height - thumbRect.height;
|
|
thumbRect.y = trackRect.y
|
|
+ (value - min) * availableHeight / (max - min - extent);
|
|
thumbRect.width = trackRect.width;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* This method returns the minimum size required for the layout.
|
|
*
|
|
* @param scrollbarContainer The Container that is laid out.
|
|
*
|
|
* @return The minimum size.
|
|
*/
|
|
public Dimension minimumLayoutSize(Container scrollbarContainer)
|
|
{
|
|
return preferredLayoutSize(scrollbarContainer);
|
|
}
|
|
|
|
/**
|
|
* This method is called when the component is painted.
|
|
*
|
|
* @param g The Graphics object to paint with.
|
|
* @param c The JComponent to paint.
|
|
*/
|
|
public void paint(Graphics g, JComponent c)
|
|
{
|
|
paintTrack(g, c, getTrackBounds());
|
|
paintThumb(g, c, getThumbBounds());
|
|
|
|
if (trackHighlight == INCREASE_HIGHLIGHT)
|
|
paintIncreaseHighlight(g);
|
|
else if (trackHighlight == DECREASE_HIGHLIGHT)
|
|
paintDecreaseHighlight(g);
|
|
}
|
|
|
|
/**
|
|
* This method is called when repainting and the mouse is pressed in the
|
|
* track. It paints the track below the thumb with the trackHighlight
|
|
* color.
|
|
*
|
|
* @param g The Graphics object to paint with.
|
|
*/
|
|
protected void paintDecreaseHighlight(Graphics g)
|
|
{
|
|
Color saved = g.getColor();
|
|
|
|
g.setColor(trackHighlightColor);
|
|
if (scrollbar.getOrientation() == HORIZONTAL)
|
|
g.fillRect(trackRect.x, trackRect.y, thumbRect.x - trackRect.x,
|
|
trackRect.height);
|
|
else
|
|
g.fillRect(trackRect.x, trackRect.y, trackRect.width,
|
|
thumbRect.y - trackRect.y);
|
|
g.setColor(saved);
|
|
}
|
|
|
|
/**
|
|
* This method is called when repainting and the mouse is pressed in the
|
|
* track. It paints the track above the thumb with the trackHighlight
|
|
* color.
|
|
*
|
|
* @param g The Graphics objet to paint with.
|
|
*/
|
|
protected void paintIncreaseHighlight(Graphics g)
|
|
{
|
|
Color saved = g.getColor();
|
|
|
|
g.setColor(trackHighlightColor);
|
|
if (scrollbar.getOrientation() == HORIZONTAL)
|
|
g.fillRect(thumbRect.x + thumbRect.width, trackRect.y,
|
|
trackRect.x + trackRect.width - thumbRect.x - thumbRect.width,
|
|
trackRect.height);
|
|
else
|
|
g.fillRect(trackRect.x, thumbRect.y + thumbRect.height, trackRect.width,
|
|
trackRect.y + trackRect.height - thumbRect.y
|
|
- thumbRect.height);
|
|
g.setColor(saved);
|
|
}
|
|
|
|
/**
|
|
* This method paints the thumb.
|
|
*
|
|
* @param g The Graphics object to paint with.
|
|
* @param c The Component that is being painted.
|
|
* @param thumbBounds The thumb bounds.
|
|
*/
|
|
protected void paintThumb(Graphics g, JComponent c, Rectangle thumbBounds)
|
|
{
|
|
g.setColor(thumbColor);
|
|
g.fillRect(thumbBounds.x, thumbBounds.y, thumbBounds.width,
|
|
thumbBounds.height);
|
|
|
|
BasicGraphicsUtils.drawBezel(g, thumbBounds.x, thumbBounds.y,
|
|
thumbBounds.width, thumbBounds.height,
|
|
false, false, thumbDarkShadowColor,
|
|
thumbDarkShadowColor, thumbHighlightColor,
|
|
thumbHighlightColor);
|
|
}
|
|
|
|
/**
|
|
* This method paints the track.
|
|
*
|
|
* @param g The Graphics object to paint with.
|
|
* @param c The JComponent being painted.
|
|
* @param trackBounds The track's bounds.
|
|
*/
|
|
protected void paintTrack(Graphics g, JComponent c, Rectangle trackBounds)
|
|
{
|
|
Color saved = g.getColor();
|
|
g.setColor(trackColor);
|
|
g.fill3DRect(trackBounds.x, trackBounds.y, trackBounds.width,
|
|
trackBounds.height, false);
|
|
g.setColor(saved);
|
|
}
|
|
|
|
/**
|
|
* This method returns the preferred size for the layout.
|
|
*
|
|
* @param scrollbarContainer The Container to find a size for.
|
|
*
|
|
* @return The preferred size for the layout.
|
|
*/
|
|
public Dimension preferredLayoutSize(Container scrollbarContainer)
|
|
{
|
|
if (scrollbarContainer instanceof JComponent)
|
|
return getPreferredSize((JComponent) scrollbarContainer);
|
|
else
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* This method removes a child component from the layout.
|
|
*
|
|
* @param child The child to remove.
|
|
*/
|
|
public void removeLayoutComponent(Component child)
|
|
{
|
|
// You should not be removing stuff from this component.
|
|
}
|
|
|
|
/**
|
|
* The method scrolls the thumb by a block in the direction specified.
|
|
*
|
|
* @param direction The direction to scroll.
|
|
*/
|
|
protected void scrollByBlock(int direction)
|
|
{
|
|
scrollByBlock(scrollbar, direction);
|
|
}
|
|
|
|
/**
|
|
* Scrolls the specified <code>scrollBar</code> by one block (according
|
|
* to the scrollable protocol) in the specified <code>direction</code>.
|
|
*
|
|
* This method is here statically to support wheel scrolling from the
|
|
* BasicScrollPaneUI without code duplication.
|
|
*
|
|
* @param scrollBar the scrollbar to scroll
|
|
* @param direction the scroll direction
|
|
*/
|
|
static final void scrollByBlock(JScrollBar scrollBar, int direction)
|
|
{
|
|
int delta;
|
|
if (direction > 0)
|
|
delta = scrollBar.getBlockIncrement(direction);
|
|
else
|
|
delta = - scrollBar.getBlockIncrement(direction);
|
|
int oldValue = scrollBar.getValue();
|
|
int newValue = oldValue + delta;
|
|
|
|
// Overflow check.
|
|
if (delta > 0 && newValue < oldValue)
|
|
newValue = scrollBar.getMaximum();
|
|
else if (delta < 0 && newValue > oldValue)
|
|
newValue = scrollBar.getMinimum();
|
|
|
|
scrollBar.setValue(newValue);
|
|
}
|
|
|
|
/**
|
|
* The method scrolls the thumb by a unit in the direction specified.
|
|
*
|
|
* @param direction The direction to scroll.
|
|
*/
|
|
protected void scrollByUnit(int direction)
|
|
{
|
|
scrollByUnits(scrollbar, direction, 1);
|
|
}
|
|
|
|
/**
|
|
* Scrolls the specified <code>scrollbac/code> by <code>units</code> units
|
|
* in the specified <code>direction</code>.
|
|
*
|
|
* This method is here statically to support wheel scrolling from the
|
|
* BasicScrollPaneUI without code duplication.
|
|
*
|
|
* @param scrollBar the scrollbar to scroll
|
|
* @param direction the direction
|
|
* @param units the number of units to scroll
|
|
*/
|
|
static final void scrollByUnits(JScrollBar scrollBar, int direction,
|
|
int units)
|
|
{
|
|
// Do this inside a loop so that we don't clash with the scrollable
|
|
// interface, which can return different units at times. For instance,
|
|
// a Scrollable could return a unit of 2 pixels only to adjust the
|
|
// visibility of an item. If we would simply multiply this by units,
|
|
// then we would only get 6 pixels, which is complete crap.
|
|
for (int i = 0; i < units; i++)
|
|
{
|
|
int delta;
|
|
if (direction > 0)
|
|
delta = scrollBar.getUnitIncrement(direction);
|
|
else
|
|
delta = - scrollBar.getUnitIncrement(direction);
|
|
int oldValue = scrollBar.getValue();
|
|
int newValue = oldValue + delta;
|
|
|
|
// Overflow check.
|
|
if (delta > 0 && newValue < oldValue)
|
|
newValue = scrollBar.getMaximum();
|
|
else if (delta < 0 && newValue > oldValue)
|
|
newValue = scrollBar.getMinimum();
|
|
|
|
scrollBar.setValue(newValue);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method sets the thumb's bounds.
|
|
*
|
|
* @param x The X position of the thumb.
|
|
* @param y The Y position of the thumb.
|
|
* @param width The width of the thumb.
|
|
* @param height The height of the thumb.
|
|
*/
|
|
protected void setThumbBounds(int x, int y, int width, int height)
|
|
{
|
|
thumbRect.x = x;
|
|
thumbRect.y = y;
|
|
thumbRect.width = width;
|
|
thumbRect.height = height;
|
|
}
|
|
|
|
/**
|
|
* This method uninstalls any components that are a part of or related to
|
|
* this scrollbar.
|
|
*/
|
|
protected void uninstallComponents()
|
|
{
|
|
if (incrButton != null)
|
|
scrollbar.remove(incrButton);
|
|
if (decrButton != null)
|
|
scrollbar.remove(decrButton);
|
|
}
|
|
|
|
/**
|
|
* This method uninstalls any defaults that this scrollbar acquired from the
|
|
* Basic Look and Feel defaults.
|
|
*/
|
|
protected void uninstallDefaults()
|
|
{
|
|
scrollbar.setForeground(null);
|
|
scrollbar.setBackground(null);
|
|
LookAndFeel.uninstallBorder(scrollbar);
|
|
incrButton = null;
|
|
decrButton = null;
|
|
}
|
|
|
|
/**
|
|
* This method uninstalls any listeners that were registered during install.
|
|
*/
|
|
protected void uninstallListeners()
|
|
{
|
|
if (scrollTimer != null)
|
|
scrollTimer.removeActionListener(scrollListener);
|
|
|
|
if (scrollbar != null)
|
|
{
|
|
scrollbar.getModel().removeChangeListener(modelListener);
|
|
scrollbar.removePropertyChangeListener(propertyChangeListener);
|
|
scrollbar.removeMouseListener(trackListener);
|
|
scrollbar.removeMouseMotionListener(trackListener);
|
|
}
|
|
|
|
if (decrButton != null)
|
|
decrButton.removeMouseListener(buttonListener);
|
|
if (incrButton != null)
|
|
incrButton.removeMouseListener(buttonListener);
|
|
|
|
propertyChangeListener = null;
|
|
modelListener = null;
|
|
buttonListener = null;
|
|
trackListener = null;
|
|
scrollListener = null;
|
|
}
|
|
|
|
/**
|
|
* This method uninstalls the UI. This includes removing any defaults,
|
|
* listeners, and components that this UI may have initialized. It also
|
|
* nulls any instance data.
|
|
*
|
|
* @param c The Component to uninstall for.
|
|
*/
|
|
public void uninstallUI(JComponent c)
|
|
{
|
|
uninstallKeyboardActions();
|
|
uninstallListeners();
|
|
uninstallDefaults();
|
|
uninstallComponents();
|
|
|
|
scrollTimer = null;
|
|
|
|
thumbRect = null;
|
|
trackRect = null;
|
|
|
|
trackColor = null;
|
|
trackHighlightColor = null;
|
|
thumbColor = null;
|
|
thumbHighlightColor = null;
|
|
thumbDarkShadowColor = null;
|
|
thumbLightShadowColor = null;
|
|
|
|
scrollbar = null;
|
|
}
|
|
|
|
/**
|
|
* This method returns the value in the scrollbar's range given the y
|
|
* coordinate. If the value is out of range, it will return the closest
|
|
* legal value.
|
|
* This is package-private to avoid an accessor method.
|
|
*
|
|
* @param yPos The y coordinate to calculate a value for.
|
|
*
|
|
* @return The value for the y coordinate.
|
|
*/
|
|
int valueForYPosition(int yPos)
|
|
{
|
|
int min = scrollbar.getMinimum();
|
|
int max = scrollbar.getMaximum();
|
|
int len = trackRect.height;
|
|
|
|
int value;
|
|
|
|
// If the length is 0, you shouldn't be able to even see where the thumb is.
|
|
// This really shouldn't ever happen, but just in case, we'll return the middle.
|
|
if (len == 0)
|
|
return (max - min) / 2;
|
|
|
|
value = (yPos - trackRect.y) * (max - min) / len + min;
|
|
|
|
// If this isn't a legal value, then we'll have to move to one now.
|
|
if (value > max)
|
|
value = max;
|
|
else if (value < min)
|
|
value = min;
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* This method returns the value in the scrollbar's range given the x
|
|
* coordinate. If the value is out of range, it will return the closest
|
|
* legal value.
|
|
* This is package-private to avoid an accessor method.
|
|
*
|
|
* @param xPos The x coordinate to calculate a value for.
|
|
*
|
|
* @return The value for the x coordinate.
|
|
*/
|
|
int valueForXPosition(int xPos)
|
|
{
|
|
int min = scrollbar.getMinimum();
|
|
int max = scrollbar.getMaximum();
|
|
int len = trackRect.width;
|
|
|
|
int value;
|
|
|
|
// If the length is 0, you shouldn't be able to even see where the slider is.
|
|
// This really shouldn't ever happen, but just in case, we'll return the middle.
|
|
if (len == 0)
|
|
return (max - min) / 2;
|
|
|
|
value = (xPos - trackRect.x) * (max - min) / len + min;
|
|
|
|
// If this isn't a legal value, then we'll have to move to one now.
|
|
if (value > max)
|
|
value = max;
|
|
else if (value < min)
|
|
value = min;
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Returns true if the mouse is over the thumb.
|
|
*
|
|
* @return true if the mouse is over the thumb.
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public boolean isThumbRollover()
|
|
{
|
|
return thumbRollover;
|
|
}
|
|
|
|
/**
|
|
* Set thumbRollover to active. This indicates
|
|
* whether or not the mouse is over the thumb.
|
|
*
|
|
* @param active - true if the mouse is over the thumb.
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
protected void setThumbRollover(boolean active)
|
|
{
|
|
thumbRollover = active;
|
|
}
|
|
|
|
/**
|
|
* Indicates whether the user can position the thumb with
|
|
* a mouse click (i.e. middle button).
|
|
*
|
|
* @return true if the user can position the thumb with a mouse
|
|
* click.
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public boolean getSupportsAbsolutePositioning()
|
|
{
|
|
// The positioning feature has not been implemented.
|
|
// So, false is always returned.
|
|
return false;
|
|
}
|
|
}
|