/*
* Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.apple.laf;
import java.awt.*;
import java.awt.event.*;
import java.beans.*;
import java.util.*;
import javax.swing.*;
import javax.swing.Timer;
import javax.swing.event.*;
import javax.swing.plaf.*;
import apple.laf.*;
import apple.laf.JRSUIConstants.*;
import apple.laf.JRSUIState.ScrollBarState;
import com.apple.laf.AquaUtils.RecyclableSingleton;
public class AquaScrollBarUI extends ScrollBarUI {
private static final int kInitialDelay = 300;
private static final int kNormalDelay = 100;
// when we make small and mini scrollbars, this will no longer be a constant
static final int MIN_ARROW_COLLAPSE_SIZE = 64;
// tracking state
protected boolean fIsDragging;
protected Timer fScrollTimer;
protected ScrollListener fScrollListener;
protected TrackListener fTrackListener;
protected Hit fTrackHighlight = Hit.NONE;
protected Hit fMousePart = Hit.NONE; // Which arrow (if any) we moused pressed down in (used by arrow drag tracking)
protected JScrollBar fScrollBar;
protected ModelListener fModelListener;
protected PropertyChangeListener fPropertyChangeListener;
protected final AquaPainter<ScrollBarState> painter = AquaPainter.create(JRSUIStateFactory.getScrollBar());
// Create PLAF
public static ComponentUI createUI(final JComponent c) {
return new AquaScrollBarUI();
}
public AquaScrollBarUI() { }
public void installUI(final JComponent c) {
fScrollBar = (JScrollBar)c;
installListeners();
configureScrollBarColors();
}
public void uninstallUI(final JComponent c) {
uninstallListeners();
fScrollBar = null;
}
protected void configureScrollBarColors() {
LookAndFeel.installColors(fScrollBar, "ScrollBar.background", "ScrollBar.foreground");
}
protected TrackListener createTrackListener() {
return new TrackListener();
}
protected ScrollListener createScrollListener() {
return new ScrollListener();
}
protected void installListeners() {
fTrackListener = createTrackListener();
fModelListener = createModelListener();
fPropertyChangeListener = createPropertyChangeListener();
fScrollBar.addMouseListener(fTrackListener);
fScrollBar.addMouseMotionListener(fTrackListener);
fScrollBar.getModel().addChangeListener(fModelListener);
fScrollBar.addPropertyChangeListener(fPropertyChangeListener);
fScrollListener = createScrollListener();
fScrollTimer = new Timer(kNormalDelay, fScrollListener);
fScrollTimer.setInitialDelay(kInitialDelay); // default InitialDelay?
}
protected void uninstallListeners() {
fScrollTimer.stop();
fScrollTimer = null;
fScrollBar.getModel().removeChangeListener(fModelListener);
fScrollBar.removeMouseListener(fTrackListener);
fScrollBar.removeMouseMotionListener(fTrackListener);
fScrollBar.removePropertyChangeListener(fPropertyChangeListener);
}
protected PropertyChangeListener createPropertyChangeListener() {
return new PropertyChangeHandler();
}
protected ModelListener createModelListener() {
return new ModelListener();
}
protected void syncState(final JComponent c) {
final ScrollBarState scrollBarState = painter.state;
scrollBarState.set(isHorizontal() ? Orientation.HORIZONTAL : Orientation.VERTICAL);
final float trackExtent = fScrollBar.getMaximum() - fScrollBar.getMinimum() - fScrollBar.getModel().getExtent();
if (trackExtent <= 0.0f) {
scrollBarState.set(NothingToScroll.YES);
return;
}
final ScrollBarPart pressedPart = getPressedPart();
scrollBarState.set(pressedPart);
scrollBarState.set(getState(c, pressedPart));
scrollBarState.set(NothingToScroll.NO);
scrollBarState.setValue((fScrollBar.getValue() - fScrollBar.getMinimum()) / trackExtent);
scrollBarState.setThumbStart(getThumbStart());
scrollBarState.setThumbPercent(getThumbPercent());
scrollBarState.set(shouldShowArrows() ? ShowArrows.YES : ShowArrows.NO);
}
public void paint(final Graphics g, final JComponent c) {
syncState(c);
painter.paint(g, c, 0, 0, fScrollBar.getWidth(), fScrollBar.getHeight());
}
protected State getState(final JComponent c, final ScrollBarPart pressedPart) {
if (!AquaFocusHandler.isActive(c)) return State.INACTIVE;
if (!c.isEnabled()) return State.INACTIVE;
if (pressedPart != ScrollBarPart.NONE) return State.PRESSED;
return State.ACTIVE;
}
static final RecyclableSingleton<Map<Hit, ScrollBarPart>> hitToPressedPartMap = new RecyclableSingleton<Map<Hit,ScrollBarPart>>(){
@Override
protected Map<Hit, ScrollBarPart> getInstance() {
final Map<Hit, ScrollBarPart> map = new HashMap<Hit, ScrollBarPart>(7);
map.put(ScrollBarHit.ARROW_MAX, ScrollBarPart.ARROW_MAX);
map.put(ScrollBarHit.ARROW_MIN, ScrollBarPart.ARROW_MIN);
map.put(ScrollBarHit.ARROW_MAX_INSIDE, ScrollBarPart.ARROW_MAX_INSIDE);
map.put(ScrollBarHit.ARROW_MIN_INSIDE, ScrollBarPart.ARROW_MIN_INSIDE);
map.put(ScrollBarHit.TRACK_MAX, ScrollBarPart.TRACK_MAX);
map.put(ScrollBarHit.TRACK_MIN, ScrollBarPart.TRACK_MIN);
map.put(ScrollBarHit.THUMB, ScrollBarPart.THUMB);
return map;
}
};
protected ScrollBarPart getPressedPart() {
if (!fTrackListener.fInArrows || !fTrackListener.fStillInArrow) return ScrollBarPart.NONE;
final ScrollBarPart pressedPart = hitToPressedPartMap.get().get(fMousePart);
if (pressedPart == null) return ScrollBarPart.NONE;
return pressedPart;
}
protected boolean shouldShowArrows() {
return MIN_ARROW_COLLAPSE_SIZE < (isHorizontal() ? fScrollBar.getWidth() : fScrollBar.getHeight());
}
// Layout Methods
// Layout is controlled by the user in the Appearance Control Panel
// Theme will redraw correctly for the current layout
public void layoutContainer(final Container fScrollBarContainer) {
fScrollBar.repaint();
fScrollBar.revalidate();
}
protected Rectangle getTrackBounds() {
return new Rectangle(0, 0, fScrollBar.getWidth(), fScrollBar.getHeight());
}
protected Rectangle getDragBounds() {
return new Rectangle(0, 0, fScrollBar.getWidth(), fScrollBar.getHeight());
}
protected void startTimer(final boolean initial) {
fScrollTimer.setInitialDelay(initial ? kInitialDelay : kNormalDelay); // default InitialDelay?
fScrollTimer.start();
}
protected void scrollByBlock(final int direction) {
synchronized(fScrollBar) {
final int oldValue = fScrollBar.getValue();
final int blockIncrement = fScrollBar.getBlockIncrement(direction);
final int delta = blockIncrement * ((direction > 0) ? +1 : -1);
fScrollBar.setValue(oldValue + delta);
fTrackHighlight = direction > 0 ? ScrollBarHit.TRACK_MAX : ScrollBarHit.TRACK_MIN;
fScrollBar.repaint();
fScrollListener.setDirection(direction);
fScrollListener.setScrollByBlock(true);
}
}
protected void scrollByUnit(final int direction) {
synchronized(fScrollBar) {
int delta = fScrollBar.getUnitIncrement(direction);
if (direction <= 0) delta = -delta;
fScrollBar.setValue(delta + fScrollBar.getValue());
fScrollBar.repaint();
fScrollListener.setDirection(direction);
fScrollListener.setScrollByBlock(false);
}
}
protected Hit getPartHit(final int x, final int y) {
syncState(fScrollBar);
return JRSUIUtils.HitDetection.getHitForPoint(painter.getControl(), 0, 0, fScrollBar.getWidth(), fScrollBar.getHeight(), x, y);
}
protected class PropertyChangeHandler implements PropertyChangeListener {
public void propertyChange(final PropertyChangeEvent e) {
final String propertyName = e.getPropertyName();
if ("model".equals(propertyName)) {
final BoundedRangeModel oldModel = (BoundedRangeModel)e.getOldValue();
final BoundedRangeModel newModel = (BoundedRangeModel)e.getNewValue();
oldModel.removeChangeListener(fModelListener);
newModel.addChangeListener(fModelListener);
fScrollBar.repaint();
fScrollBar.revalidate();
} else if (AquaFocusHandler.FRAME_ACTIVE_PROPERTY.equals(propertyName)) {
fScrollBar.repaint();
}
}
}
protected class ModelListener implements ChangeListener {
public void stateChanged(final ChangeEvent e) {
layoutContainer(fScrollBar);
}
}
// Track mouse drags.
protected class TrackListener extends MouseAdapter implements MouseMotionListener {
protected transient int fCurrentMouseX, fCurrentMouseY;
protected transient boolean fInArrows; // are we currently tracking arrows?
protected transient boolean fStillInArrow = false; // Whether mouse is in an arrow during arrow tracking
protected transient boolean fStillInTrack = false; // Whether mouse is in the track during pageup/down tracking
protected transient int fFirstMouseX, fFirstMouseY, fFirstValue; // Values for getValueFromOffset
public void mouseReleased(final MouseEvent e) {
if (!fScrollBar.isEnabled()) return;
if (fInArrows) {
mouseReleasedInArrows(e);
} else {
mouseReleasedInTrack(e);
}
fInArrows = false;
fStillInArrow = false;
fStillInTrack = false;
fScrollBar.repaint();
fScrollBar.revalidate();
}
public void mousePressed(final MouseEvent e) {
if (!fScrollBar.isEnabled()) return;
final Hit part = getPartHit(e.getX(), e.getY());
fInArrows = HitUtil.isArrow(part);
if (fInArrows) {
mousePressedInArrows(e, part);
} else {
if (part == Hit.NONE) {
fTrackHighlight = Hit.NONE;
} else {
mousePressedInTrack(e, part);
}
}
}
public void mouseDragged(final MouseEvent e) {
if (!fScrollBar.isEnabled()) return;
if (fInArrows) {
mouseDraggedInArrows(e);
} else if (fIsDragging) {
mouseDraggedInTrack(e);
} else {
// In pageup/down zones
// check that thumb has not been scrolled under the mouse cursor
final Hit previousPart = getPartHit(fCurrentMouseX, fCurrentMouseY);
if (!HitUtil.isTrack(previousPart)) {
fStillInTrack = false;
}
fCurrentMouseX = e.getX();
fCurrentMouseY = e.getY();
final Hit part = getPartHit(e.getX(), e.getY());
final boolean temp = HitUtil.isTrack(part);
if (temp == fStillInTrack) return;
fStillInTrack = temp;
if (!fStillInTrack) {
fScrollTimer.stop();
} else {
fScrollListener.actionPerformed(new ActionEvent(fScrollTimer, 0, ""));
startTimer(false);
}
}
}
int getValueFromOffset(final int xOffset, final int yOffset, final int firstValue) {
final boolean isHoriz = isHorizontal();
// find the amount of pixels we've moved x & y (we only care about one)
final int offsetWeCareAbout = isHoriz ? xOffset : yOffset;
// now based on that floating point percentage compute the real scroller value.
final int visibleAmt = fScrollBar.getVisibleAmount();
final int max = fScrollBar.getMaximum();
final int min = fScrollBar.getMinimum();
final int extent = max - min;
// ask native to tell us what the new float that is a ratio of how much scrollable area
// we have moved (not the thumb area, just the scrollable). If the
// scroller goes 0-100 with a visible area of 20 we are getting a ratio of the
// remaining 80.
syncState(fScrollBar);
final double offsetChange = JRSUIUtils.ScrollBar.getNativeOffsetChange(painter.getControl(), 0, 0, fScrollBar.getWidth(), fScrollBar.getHeight(), offsetWeCareAbout, visibleAmt, extent);
// the scrollable area is the extent - visible amount;
final int scrollableArea = extent - visibleAmt;
final int changeByValue = (int)(offsetChange * scrollableArea);
int newValue = firstValue + changeByValue;
newValue = Math.max(min, newValue);
newValue = Math.min((max - visibleAmt), newValue);
return newValue;
}
/**
* Arrow Listeners
*/
// 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
void mousePressedInArrows(final MouseEvent e, final Hit part) {
final int direction = HitUtil.isIncrement(part) ? 1 : -1;
fStillInArrow = true;
scrollByUnit(direction);
fScrollTimer.stop();
fScrollListener.setDirection(direction);
fScrollListener.setScrollByBlock(false);
fMousePart = part;
startTimer(true);
}
void mouseReleasedInArrows(final MouseEvent e) {
fScrollTimer.stop();
fMousePart = Hit.NONE;
fScrollBar.setValueIsAdjusting(false);
}
void mouseDraggedInArrows(final MouseEvent e) {
final Hit whichPart = getPartHit(e.getX(), e.getY());
if ((fMousePart == whichPart) && fStillInArrow) return; // Nothing has changed, so return
if (fMousePart != whichPart && !HitUtil.isArrow(whichPart)) {
// The mouse is not over the arrow we mouse pressed in, so stop the timer and mark as
// not being in the arrow
fScrollTimer.stop();
fStillInArrow = false;
fScrollBar.repaint();
} else {
// We are in the arrow we mouse pressed down in originally, but the timer was stopped so we need
// to start it up again.
fMousePart = whichPart;
fScrollListener.setDirection(HitUtil.isIncrement(whichPart) ? 1 : -1);
fStillInArrow = true;
fScrollListener.actionPerformed(new ActionEvent(fScrollTimer, 0, ""));
startTimer(false);
}
fScrollBar.repaint();
}
void mouseReleasedInTrack(final MouseEvent e) {
if (fTrackHighlight != Hit.NONE) {
fScrollBar.repaint();
}
fTrackHighlight = Hit.NONE;
fIsDragging = false;
fScrollTimer.stop();
fScrollBar.setValueIsAdjusting(false);
}
/**
* Adjust the fScrollBars value based on the result of hitTestTrack
*/
void mousePressedInTrack(final MouseEvent e, final Hit part) {
fScrollBar.setValueIsAdjusting(true);
// If option-click, toggle scroll-to-here
boolean shouldScrollToHere = (part != ScrollBarHit.THUMB) && JRSUIUtils.ScrollBar.useScrollToClick();
if (e.isAltDown()) shouldScrollToHere = !shouldScrollToHere;
// pretend the mouse was dragged from a point in the current thumb to the current mouse point in one big jump
if (shouldScrollToHere) {
final Point p = getScrollToHereStartPoint(e.getX(), e.getY());
fFirstMouseX = p.x;
fFirstMouseY = p.y;
fFirstValue = fScrollBar.getValue();
moveToMouse(e);
// OK, now we're in the thumb - any subsequent dragging should move it
fTrackHighlight = ScrollBarHit.THUMB;
fIsDragging = true;
return;
}
fCurrentMouseX = e.getX();
fCurrentMouseY = e.getY();
int direction = 0;
if (part == ScrollBarHit.TRACK_MIN) {
fTrackHighlight = ScrollBarHit.TRACK_MIN;
direction = -1;
} else if (part == ScrollBarHit.TRACK_MAX) {
fTrackHighlight = ScrollBarHit.TRACK_MAX;
direction = 1;
} else {
fFirstValue = fScrollBar.getValue();
fFirstMouseX = fCurrentMouseX;
fFirstMouseY = fCurrentMouseY;
fTrackHighlight = ScrollBarHit.THUMB;
fIsDragging = true;
return;
}
fIsDragging = false;
fStillInTrack = true;
scrollByBlock(direction);
// Check the new location of the thumb
// stop scrolling if the thumb is under the mouse??
final Hit newPart = getPartHit(fCurrentMouseX, fCurrentMouseY);
if (newPart == ScrollBarHit.TRACK_MIN || newPart == ScrollBarHit.TRACK_MAX) {
fScrollTimer.stop();
fScrollListener.setDirection(((newPart == ScrollBarHit.TRACK_MAX) ? 1 : -1));
fScrollListener.setScrollByBlock(true);
startTimer(true);
}
}
/**
* Set the models value to the position of the top/left
* of the thumb relative to the origin of the track.
*/
void mouseDraggedInTrack(final MouseEvent e) {
moveToMouse(e);
}
// For normal mouse dragging or click-to-here
// fCurrentMouseX, fCurrentMouseY, and fFirstValue must be set
void moveToMouse(final MouseEvent e) {
fCurrentMouseX = e.getX();
fCurrentMouseY = e.getY();
final int oldValue = fScrollBar.getValue();
final int newValue = getValueFromOffset(fCurrentMouseX - fFirstMouseX, fCurrentMouseY - fFirstMouseY, fFirstValue);
if (newValue == oldValue) return;
fScrollBar.setValue(newValue);
final Rectangle dirtyRect = getTrackBounds();
fScrollBar.repaint(dirtyRect.x, dirtyRect.y, dirtyRect.width, dirtyRect.height);
}
}
/**
* Listener for scrolling events initiated in the ScrollPane.
*/
protected class ScrollListener implements ActionListener {
boolean fUseBlockIncrement;
int fDirection = 1;
void setDirection(final int direction) {
this.fDirection = direction;
}
void setScrollByBlock(final boolean block) {
this.fUseBlockIncrement = block;
}
public void actionPerformed(final ActionEvent e) {
if (fUseBlockIncrement) {
Hit newPart = getPartHit(fTrackListener.fCurrentMouseX, fTrackListener.fCurrentMouseY);
if (newPart == ScrollBarHit.TRACK_MIN || newPart == ScrollBarHit.TRACK_MAX) {
final int newDirection = (newPart == ScrollBarHit.TRACK_MAX ? 1 : -1);
if (fDirection != newDirection) {
fDirection = newDirection;
}
}
scrollByBlock(fDirection);
newPart = getPartHit(fTrackListener.fCurrentMouseX, fTrackListener.fCurrentMouseY);
if (newPart == ScrollBarHit.THUMB) {
((Timer)e.getSource()).stop();
}
} else {
scrollByUnit(fDirection);
}
if (fDirection > 0 && fScrollBar.getValue() + fScrollBar.getVisibleAmount() >= fScrollBar.getMaximum()) {
((Timer)e.getSource()).stop();
} else if (fDirection < 0 && fScrollBar.getValue() <= fScrollBar.getMinimum()) {
((Timer)e.getSource()).stop();
}
}
}
float getThumbStart() {
final int max = fScrollBar.getMaximum();
final int min = fScrollBar.getMinimum();
final int extent = max - min;
if (extent <= 0) return 0f;
return (float)(fScrollBar.getValue() - fScrollBar.getMinimum()) / (float)extent;
}
float getThumbPercent() {
final int visible = fScrollBar.getVisibleAmount();
final int max = fScrollBar.getMaximum();
final int min = fScrollBar.getMinimum();
final int extent = max - min;
if (extent <= 0) return 0f;
return (float)visible / (float)extent;
}
/**
* A scrollbar's preferred width is 16 by a reasonable size to hold
* the arrows
*
* @param c The JScrollBar that's delegating this method to us.
* @return The preferred size of a Basic JScrollBar.
* @see #getMaximumSize
* @see #getMinimumSize
*/
public Dimension getPreferredSize(final JComponent c) {
return isHorizontal() ? new Dimension(96, 15) : new Dimension(15, 96);
}
public Dimension getMinimumSize(final JComponent c) {
return isHorizontal() ? new Dimension(54, 15) : new Dimension(15, 54);
}
public Dimension getMaximumSize(final JComponent c) {
return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
}
boolean isHorizontal() {
return fScrollBar.getOrientation() == Adjustable.HORIZONTAL;
}
// only do scroll-to-here for page up and page down regions, when the option key is pressed
// This gets the point where the mouse would have been clicked in the current thumb
// so we can pretend the mouse was dragged to the current mouse point in one big jump
Point getScrollToHereStartPoint(final int clickPosX, final int clickPosY) {
// prepare the track rectangle and limit rectangle so we can do our calculations
final Rectangle limitRect = getDragBounds(); // GetThemeTrackDragRect
// determine the bounding rectangle for our thumb region
syncState(fScrollBar);
double[] rect = new double[4];
JRSUIUtils.ScrollBar.getPartBounds(rect, painter.getControl(), 0, 0, fScrollBar.getWidth(), fScrollBar.getHeight(), ScrollBarPart.THUMB);
final Rectangle r = new Rectangle((int)rect[0], (int)rect[1], (int)rect[2], (int)rect[3]);
// figure out the scroll-to-here start location based on our orientation, the
// click position, and where it must be in the thumb to travel to the endpoints
// properly.
final Point startPoint = new Point(clickPosX, clickPosY);
if (isHorizontal()) {
final int halfWidth = r.width / 2;
final int limitRectRight = limitRect.x + limitRect.width;
if (clickPosX + halfWidth > limitRectRight) {
// Up against right edge
startPoint.x = r.x + r.width - limitRectRight - clickPosX - 1;
} else if (clickPosX - halfWidth < limitRect.x) {
// Up against left edge
startPoint.x = r.x + clickPosX - limitRect.x;
} else {
// Center the thumb
startPoint.x = r.x + halfWidth;
}
// Pretend clicked in middle of indicator vertically
startPoint.y = (r.y + r.height) / 2;
return startPoint;
}
final int halfHeight = r.height / 2;
final int limitRectBottom = limitRect.y + limitRect.height;
if (clickPosY + halfHeight > limitRectBottom) {
// Up against bottom edge
startPoint.y = r.y + r.height - limitRectBottom - clickPosY - 1;
} else if (clickPosY - halfHeight < limitRect.y) {
// Up against top edge
startPoint.y = r.y + clickPosY - limitRect.y;
} else {
// Center the thumb
startPoint.y = r.y + halfHeight;
}
// Pretend clicked in middle of indicator horizontally
startPoint.x = (r.x + r.width) / 2;
return startPoint;
}
static class HitUtil {
static boolean isIncrement(final Hit hit) {
return (hit == ScrollBarHit.ARROW_MAX) || (hit == ScrollBarHit.ARROW_MAX_INSIDE);
}
static boolean isDecrement(final Hit hit) {
return (hit == ScrollBarHit.ARROW_MIN) || (hit == ScrollBarHit.ARROW_MIN_INSIDE);
}
static boolean isArrow(final Hit hit) {
return isIncrement(hit) || isDecrement(hit);
}
static boolean isTrack(final Hit hit) {
return (hit == ScrollBarHit.TRACK_MAX) || (hit == ScrollBarHit.TRACK_MIN);
}
}
}