Smooth scrolling

flatlaf-core/src/main/java/com/formdev/flatlaf/FlatSystemProperties.java

@@ -132,6 +132,14 @@ public interface FlatSystemProperties
 	 */
 	String ANIMATION = "flatlaf.animation";
 
+	/**
+	 * Specifies whether smooth scrolling is enabled.
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> {@code true}
+	 */
+	String SMOOTH_SCROLLING = "flatlaf.smoothScrolling";
+
 	/**
 	 * Specifies whether vertical text position is corrected when UI is scaled on HiDPI screens.
 	 * <p>

flatlaf-core/src/main/java/com/formdev/flatlaf/ui/FlatEditorPaneUI.java

@@ -31,6 +31,7 @@
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.basic.BasicEditorPaneUI;
 import javax.swing.text.Caret;
+import javax.swing.text.DefaultEditorKit;
 import javax.swing.text.JTextComponent;
 import com.formdev.flatlaf.FlatClientProperties;
 import com.formdev.flatlaf.ui.FlatStylingSupport.Styleable;
@@ -145,6 +146,21 @@ protected void uninstallListeners() {
 		focusListener = null;
 	}
 
+	@Override
+	protected void installKeyboardActions() {
+		super.installKeyboardActions();
+		installKeyboardActions( getComponent() );
+	}
+
+	static void installKeyboardActions( JTextComponent c ) {
+		FlatScrollPaneUI.installSmoothScrollingDelegateActions( c, false,
+			/* page-down */ DefaultEditorKit.pageDownAction,						// PAGE_DOWN
+			/* page-up */ DefaultEditorKit.pageUpAction,							// PAGE_UP
+			/* DefaultEditorKit.selectionPageDownAction */ "selection-page-down",	// shift PAGE_DOWN
+			/* DefaultEditorKit.selectionPageUpAction */ "selection-page-up"		// shift PAGE_UP
+		);
+	}
+
 	@Override
 	protected Caret createCaret() {
 		return new FlatCaret( null, false );
@@ -159,6 +175,11 @@ protected void propertyChange( PropertyChangeEvent e ) {
 
 		super.propertyChange( e );
 		propertyChange( getComponent(), e, this::installStyle );
+
+		// BasicEditorPaneUI.propertyChange() re-applied actions from editor kit,
+		// which removed our delegate actions
+		if( "editorKit".equals( propertyName ) )
+			installKeyboardActions( getComponent() );
 	}
 
 	static void propertyChange( JTextComponent c, PropertyChangeEvent e, Runnable installStyle ) {

flatlaf-core/src/main/java/com/formdev/flatlaf/ui/FlatMenuBarUI.java

@@ -27,7 +27,6 @@
 import java.beans.PropertyChangeListener;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicBoolean;
-import javax.swing.AbstractAction;
 import javax.swing.ActionMap;
 import javax.swing.BoxLayout;
 import javax.swing.JComponent;
@@ -149,7 +148,7 @@ protected void installKeyboardActions() {
 			map = new ActionMapUIResource();
 			SwingUtilities.replaceUIActionMap( menuBar, map );
 		}
-		map.put( "takeFocus", new TakeFocus() );
+		map.put( "takeFocus", new TakeFocus( "takeFocus" ) );
 	}
 
 	/** @since 2 */
@@ -373,8 +372,12 @@ public void layoutContainer( Container target ) {
 	 * On other platforms, the popup of the first menu is shown.
 	 */
 	private static class TakeFocus
-		extends AbstractAction
+		extends FlatUIAction
 	{
+		public TakeFocus( String name ) {
+			super( name );
+		}
+
 		@Override
 		public void actionPerformed( ActionEvent e ) {
 			JMenuBar menuBar = (JMenuBar) e.getSource();

flatlaf-core/src/main/java/com/formdev/flatlaf/ui/FlatScrollBarUI.java

@@ -22,6 +22,7 @@
 import java.awt.Graphics;
 import java.awt.Insets;
 import java.awt.Rectangle;
+import java.awt.event.ActionEvent;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
 import java.beans.PropertyChangeListener;
@@ -39,10 +40,13 @@
 import javax.swing.plaf.basic.BasicScrollBarUI;
 import com.formdev.flatlaf.FlatClientProperties;
 import com.formdev.flatlaf.FlatLaf;
+import com.formdev.flatlaf.FlatSystemProperties;
 import com.formdev.flatlaf.ui.FlatStylingSupport.Styleable;
 import com.formdev.flatlaf.ui.FlatStylingSupport.StyleableField;
 import com.formdev.flatlaf.ui.FlatStylingSupport.StyleableLookupProvider;
 import com.formdev.flatlaf.ui.FlatStylingSupport.StyleableUI;
+import com.formdev.flatlaf.util.Animator;
+import com.formdev.flatlaf.util.CubicBezierEasing;
 import com.formdev.flatlaf.util.LoggingFacade;
 import com.formdev.flatlaf.util.SystemInfo;
 import com.formdev.flatlaf.util.UIScale;
@@ -203,6 +207,16 @@ protected void uninstallDefaults() {
 		oldStyleValues = null;
 	}
 
+	@Override
+	protected TrackListener createTrackListener() {
+		return new FlatTrackListener();
+	}
+
+	@Override
+	protected ScrollListener createScrollListener() {
+		return new FlatScrollListener();
+	}
+
 	@Override
 	protected PropertyChangeListener createPropertyChangeListener() {
 		PropertyChangeListener superListener = super.createPropertyChangeListener();
@@ -431,6 +445,197 @@ public boolean getSupportsAbsolutePositioning() {
 		return allowsAbsolutePositioning;
 	}
 
+	@Override
+	protected void scrollByBlock( int direction ) {
+		runAndSetValueAnimated( () -> {
+			super.scrollByBlock( direction );
+		} );
+	}
+
+	@Override
+	protected void scrollByUnit( int direction ) {
+		runAndSetValueAnimated( () -> {
+			super.scrollByUnit( direction );
+		} );
+	}
+
+	/**
+	 * Runs the given runnable, which should modify the scroll bar value,
+	 * and then animate scroll bar value from old value to new value.
+	 */
+	public void runAndSetValueAnimated( Runnable r ) {
+		if( inRunAndSetValueAnimated || !isSmoothScrollingEnabled() ) {
+			r.run();
+			return;
+		}
+
+		inRunAndSetValueAnimated = true;
+
+		if( animator != null )
+			animator.cancel();
+
+		if( useValueIsAdjusting )
+			scrollbar.setValueIsAdjusting( true );
+
+		// remember current scrollbar value so that we can start scroll animation from there
+		int oldValue = scrollbar.getValue();
+
+		// run given runnable, which computes and sets the new scrollbar value
+		FlatScrollPaneUI.runWithoutBlitting( scrollbar.getParent(), () ->{
+			// if invoked while animation is running, calculation of new value
+			// should start at the previous target value
+			if( targetValue != Integer.MIN_VALUE )
+				scrollbar.setValue( targetValue );
+
+	 		r.run();
+		} );
+
+		// do not use animation if started dragging thumb
+		if( isDragging ) {
+			// do not clear valueIsAdjusting here
+			inRunAndSetValueAnimated = false;
+			return;
+		}
+
+		int newValue = scrollbar.getValue();
+		if( newValue != oldValue ) {
+			// start scroll animation if value has changed
+			setValueAnimated( oldValue, newValue );
+		} else {
+			// clear valueIsAdjusting if value has not changed
+			if( useValueIsAdjusting )
+				scrollbar.setValueIsAdjusting( false );
+		}
+
+		inRunAndSetValueAnimated = false;
+	}
+
+	private boolean inRunAndSetValueAnimated;
+	private Animator animator;
+	private int startValue = Integer.MIN_VALUE;
+	private int targetValue = Integer.MIN_VALUE;
+	private boolean useValueIsAdjusting = true;
+
+	int getTargetValue() {
+		return targetValue;
+	}
+
+	public void setValueAnimated( int initialValue, int value ) {
+		if( useValueIsAdjusting )
+			scrollbar.setValueIsAdjusting( true );
+
+		// (always) set scrollbar value to initial value
+		scrollbar.setValue( initialValue );
+
+		// do some check if animation already running
+		if( animator != null && animator.isRunning() && targetValue != Integer.MIN_VALUE ) {
+			// Ignore requests if animation still running and scroll direction is the same
+			// and new value is within currently running animation.
+			// Without this check, repeating-scrolling via keyboard would become
+			// very slow when reaching the top/bottom/left/right of the viewport,
+			// because it would start a new 200ms animation to scroll a few pixels.
+			if( value == targetValue ||
+				(value > startValue && value < targetValue) || // scroll down/right
+				(value < startValue && value > targetValue) )  // scroll up/left
+			  return;
+		}
+
+		startValue = initialValue;
+		targetValue = value;
+
+		// create animator
+		if( animator == null ) {
+			int duration = FlatUIUtils.getUIInt( "ScrollPane.smoothScrolling.duration", 200 );
+			int resolution = FlatUIUtils.getUIInt( "ScrollPane.smoothScrolling.resolution", 10 );
+			Object interpolator = UIManager.get( "ScrollPane.smoothScrolling.interpolator" );
+
+			animator = new Animator( duration, fraction -> {
+				if( scrollbar == null || !scrollbar.isShowing() ) {
+					animator.stop();
+					return;
+				}
+
+				// re-enable valueIsAdjusting if disabled while animation is running
+				// (e.g. in mouse released listener)
+				if( useValueIsAdjusting && !scrollbar.getValueIsAdjusting() )
+					scrollbar.setValueIsAdjusting( true );
+
+				scrollbar.setValue( startValue + Math.round( (targetValue - startValue) * fraction ) );
+			}, () -> {
+				startValue = targetValue = Integer.MIN_VALUE;
+
+				if( useValueIsAdjusting && scrollbar != null )
+					scrollbar.setValueIsAdjusting( false );
+			});
+
+			animator.setResolution( resolution );
+			animator.setInterpolator( (interpolator instanceof Animator.Interpolator)
+				? (Animator.Interpolator) interpolator
+				: new CubicBezierEasing( 0.5f, 0.5f, 0.5f, 1 ) );
+		}
+
+		// restart animator
+		animator.cancel();
+		animator.start();
+	}
+
+	protected boolean isSmoothScrollingEnabled() {
+		if( !Animator.useAnimation() || !FlatSystemProperties.getBoolean( FlatSystemProperties.SMOOTH_SCROLLING, true ) )
+			return false;
+
+		// if scroll bar is child of scroll pane, check only client property of scroll pane
+		Container parent = scrollbar.getParent();
+		JComponent c = (parent instanceof JScrollPane) ? (JScrollPane) parent : scrollbar;
+		Object smoothScrolling = c.getClientProperty( FlatClientProperties.SCROLL_PANE_SMOOTH_SCROLLING );
+		if( smoothScrolling instanceof Boolean )
+			return (Boolean) smoothScrolling;
+
+		// Note: Getting UI value "ScrollPane.smoothScrolling" here to allow
+		// applications to turn smooth scrolling on or off at any time
+		// (e.g. in application options dialog).
+		return UIManager.getBoolean( "ScrollPane.smoothScrolling" );
+	}
+
+	//---- class FlatTrackListener --------------------------------------------
+
+	protected class FlatTrackListener
+		extends TrackListener
+	{
+		@Override
+		public void mousePressed( MouseEvent e ) {
+			// Do not use valueIsAdjusting here (in runAndSetValueAnimated())
+			// for smooth scrolling because super.mousePressed() enables this itself
+			// and super.mouseRelease() disables it later.
+			// If we would disable valueIsAdjusting here (in runAndSetValueAnimated())
+			// and move the thumb with the mouse, then the thumb location is not updated
+			// if later scrolled with a key (e.g. HOME key).
+			useValueIsAdjusting = false;
+
+			runAndSetValueAnimated( () -> {
+				super.mousePressed( e );
+			} );
+		}
+
+		@Override
+		public void mouseReleased( MouseEvent e ) {
+			super.mouseReleased( e );
+			useValueIsAdjusting = true;
+		}
+	}
+
+	//---- class FlatScrollListener -------------------------------------------
+
+	protected class FlatScrollListener
+		extends ScrollListener
+	{
+		@Override
+		public void actionPerformed( ActionEvent e ) {
+			runAndSetValueAnimated( () -> {
+				super.actionPerformed( e );
+			} );
+		}
+	}
+
 	//---- class ScrollBarHoverListener ---------------------------------------
 
 	// using static field to disabling hover for other scroll bars