javax.swing.plaf.basic

## Class BasicScrollBarUI

- java.lang.Object
- - javax.swing.plaf.ComponentUI
  - - javax.swing.plaf.ScrollBarUI
    - - javax.swing.plaf.basic.BasicScrollBarUI

All Implemented Interfaces:
  LayoutManager, SwingConstants

Direct Known Subclasses:
  MetalScrollBarUI, SynthScrollBarUI

    public class BasicScrollBarUI
    extends ScrollBarUI
    implements LayoutManager, SwingConstants

Implementation of ScrollBarUI for the Basic Look and Feel

### Nested Class Summary

Nested Classes
`protected class` `BasicScrollBarUI.ArrowButtonListener` Listener for cursor keys.
`protected class` `BasicScrollBarUI.ModelListener` A listener to listen for model changes.
`class` `BasicScrollBarUI.PropertyChangeHandler`
`protected class` `BasicScrollBarUI.ScrollListener` Listener for scrolling events initiated in the `ScrollPane`.
`protected class` `BasicScrollBarUI.TrackListener` Track mouse drags.

### Field Summary

Fields
`protected BasicScrollBarUI.ArrowButtonListener` `buttonListener`
`protected JButton` `decrButton`
`protected static int` `DECREASE_HIGHLIGHT`
`protected int` `decrGap` Distance between the decrement button and the track.
`protected JButton` `incrButton`
`protected static int` `INCREASE_HIGHLIGHT`
`protected int` `incrGap` Distance between the increment button and the track.
`protected boolean` `isDragging`
`protected Dimension` `maximumThumbSize`
`protected Dimension` `minimumThumbSize`
`protected BasicScrollBarUI.ModelListener` `modelListener`
`protected static int` `NO_HIGHLIGHT`
`protected PropertyChangeListener` `propertyChangeListener`
`protected JScrollBar` `scrollbar`
`protected int` `scrollBarWidth` Hint as to what width (when vertical) or height (when horizontal) should be.
`protected BasicScrollBarUI.ScrollListener` `scrollListener`
`protected Timer` `scrollTimer`
`protected Color` `thumbColor`
`protected Color` `thumbDarkShadowColor`
`protected Color` `thumbHighlightColor`
`protected Color` `thumbLightShadowColor`
`protected Rectangle` `thumbRect`
`protected Color` `trackColor`
`protected int` `trackHighlight`
`protected Color` `trackHighlightColor`
`protected BasicScrollBarUI.TrackListener` `trackListener`
`protected Rectangle` `trackRect`

### Fields inherited from interface javax.swing.SwingConstants

`BOTTOM, CENTER, EAST, HORIZONTAL, LEADING, LEFT, NEXT, NORTH, NORTH_EAST, NORTH_WEST, PREVIOUS, RIGHT, SOUTH, SOUTH_EAST, SOUTH_WEST, TOP, TRAILING, VERTICAL, WEST`

### Constructor Summary

Constructors
Constructor and Description
`BasicScrollBarUI()`

### Method Summary

All Methods Static Methods Instance Methods Concrete Methods
`void` `addLayoutComponent(String name, Component child)` If the layout manager uses a per-component string, adds the component `comp` to the layout, associating it with the string specified by `name`.
`protected void` `configureScrollBarColors()`
`protected BasicScrollBarUI.ArrowButtonListener` `createArrowButtonListener()`
`protected JButton` `createDecreaseButton(int orientation)`
`protected JButton` `createIncreaseButton(int orientation)`
`protected BasicScrollBarUI.ModelListener` `createModelListener()`
`protected PropertyChangeListener` `createPropertyChangeListener()`
`protected BasicScrollBarUI.ScrollListener` `createScrollListener()`
`protected BasicScrollBarUI.TrackListener` `createTrackListener()`
`static ComponentUI` `createUI(JComponent c)`
`Dimension` `getMaximumSize(JComponent c)` Returns the specified component's maximum size appropriate for the look and feel.
`protected Dimension` `getMaximumThumbSize()` Returns the largest acceptable size for the thumb.
`protected Dimension` `getMinimumThumbSize()` Returns the smallest acceptable size for the thumb.
`Dimension` `getPreferredSize(JComponent c)` A vertical scrollbar's preferred width is the maximum of preferred widths of the (non `null`) increment/decrement buttons, and the minimum width of the thumb.
`boolean` `getSupportsAbsolutePositioning()` Indicates whether the user can absolutely position the thumb with a mouse gesture (usually the middle mouse button).
`protected Rectangle` `getThumbBounds()` Return the current size/location of the thumb.
`protected Rectangle` `getTrackBounds()` Returns the current bounds of the track, i.e.
`protected void` `installComponents()`
`protected void` `installDefaults()`
`protected void` `installKeyboardActions()`
`protected void` `installListeners()`
`void` `installUI(JComponent c)` Configures the specified component appropriately for the look and feel.
`boolean` `isThumbRollover()` Returns true if the mouse is currently over the thumb.
`void` `layoutContainer(Container scrollbarContainer)` Lays out the specified container.
`protected void` `layoutHScrollbar(JScrollBar sb)`
`protected void` `layoutVScrollbar(JScrollBar sb)`
`Dimension` `minimumLayoutSize(Container scrollbarContainer)` Calculates the minimum size dimensions for the specified container, given the components it contains.
`void` `paint(Graphics g, JComponent c)` Paints the specified component appropriately for the look and feel.
`protected void` `paintDecreaseHighlight(Graphics g)`
`protected void` `paintIncreaseHighlight(Graphics g)`
`protected void` `paintThumb(Graphics g, JComponent c, Rectangle thumbBounds)`
`protected void` `paintTrack(Graphics g, JComponent c, Rectangle trackBounds)`
`Dimension` `preferredLayoutSize(Container scrollbarContainer)` Calculates the preferred size dimensions for the specified container, given the components it contains.
`void` `removeLayoutComponent(Component child)` Removes the specified component from the layout.
`protected void` `scrollByBlock(int direction)`
`protected void` `scrollByUnit(int direction)`
`protected void` `setThumbBounds(int x, int y, int width, int height)` Set the bounds of the thumb and force a repaint that includes the old thumbBounds and the new one.
`protected void` `setThumbRollover(boolean active)` Sets whether or not the mouse is currently over the thumb.
`protected void` `uninstallComponents()`
`protected void` `uninstallDefaults()`
`protected void` `uninstallKeyboardActions()`
`protected void` `uninstallListeners()`
`void` `uninstallUI(JComponent c)` Reverses configuration which was done on the specified component during `installUI`.

### Methods inherited from class javax.swing.plaf.ComponentUI

`contains, getAccessibleChild, getAccessibleChildrenCount, getBaseline, getBaselineResizeBehavior, getMinimumSize, update`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### minimumThumbSize

    protected Dimension minimumThumbSize

#### maximumThumbSize

    protected Dimension maximumThumbSize

#### thumbHighlightColor

    protected Color thumbHighlightColor

#### thumbLightShadowColor

    protected Color thumbLightShadowColor

#### thumbDarkShadowColor

    protected Color thumbDarkShadowColor

#### thumbColor

    protected Color thumbColor

#### trackColor

    protected Color trackColor

#### trackHighlightColor

    protected Color trackHighlightColor

#### scrollbar

    protected JScrollBar scrollbar

#### incrButton

    protected JButton incrButton

#### decrButton

    protected JButton decrButton

#### isDragging

    protected boolean isDragging

#### trackListener

    protected BasicScrollBarUI.TrackListener trackListener

#### buttonListener

    protected BasicScrollBarUI.ArrowButtonListener buttonListener

#### modelListener

    protected BasicScrollBarUI.ModelListener modelListener

#### thumbRect

    protected Rectangle thumbRect

#### trackRect

    protected Rectangle trackRect

#### trackHighlight

    protected int trackHighlight

#### NO_HIGHLIGHT

    protected static final int NO_HIGHLIGHT

See Also:
  Constant Field Values

#### DECREASE_HIGHLIGHT

    protected static final int DECREASE_HIGHLIGHT

See Also:
  Constant Field Values

#### INCREASE_HIGHLIGHT

    protected static final int INCREASE_HIGHLIGHT

See Also:
  Constant Field Values

#### scrollListener

    protected BasicScrollBarUI.ScrollListener scrollListener

#### propertyChangeListener

    protected PropertyChangeListener propertyChangeListener

#### scrollTimer

    protected Timer scrollTimer

#### scrollBarWidth

    protected int scrollBarWidth

Hint as to what width (when vertical) or height (when horizontal) should be.

Since:
  1.7

#### incrGap

    protected int incrGap

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

#### decrGap

    protected int decrGap

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

### Constructor Detail

#### BasicScrollBarUI

    public BasicScrollBarUI()

### Method Detail

#### createUI

    public static ComponentUI createUI(JComponent c)

#### configureScrollBarColors

    protected void configureScrollBarColors()

#### installUI

    public void installUI(JComponent c)

Description copied from class: `ComponentUI`
Configures the specified component appropriately for the look and feel. This method is invoked when the `ComponentUI` instance is being installed as the UI delegate on the specified component. This method should completely configure the component for the look and feel, including the following:

1. Install default property values for color, fonts, borders, icons, opacity, etc. on the component. Whenever possible, property values initialized by the client program should not be overridden.
2. Install a `LayoutManager` on the component if necessary.
3. Create/add any required sub-components to the component.
4. Create/install event listeners on the component.
5. Create/install a `PropertyChangeListener` on the component in order to detect and respond to component property changes appropriately.
6. Install keyboard UI (mnemonics, traversal, etc.) on the component.
7. Initialize any appropriate instance data.

Overrides:
  `installUI` in class `ComponentUI`
Parameters:
  `c` - the component where this UI delegate is being installed
See Also:
  `ComponentUI.uninstallUI(javax.swing.JComponent)`, `JComponent.setUI(javax.swing.plaf.ComponentUI)`, `JComponent.updateUI()`

#### uninstallUI

    public void uninstallUI(JComponent c)

Description copied from class: `ComponentUI`
Reverses configuration which was done on the specified component during `installUI`. This method is invoked when this `UIComponent` instance is being removed as the UI delegate for the specified component. This method should undo the configuration performed in `installUI`, being careful to leave the `JComponent` instance in a clean state (no extraneous listeners, look-and-feel-specific property objects, etc.). This should include the following:

1. Remove any UI-set borders from the component.
2. Remove any UI-set layout managers on the component.
3. Remove any UI-added sub-components from the component.
4. Remove any UI-added event/property listeners from the component.
5. Remove any UI-installed keyboard UI from the component.
6. Nullify any allocated instance data objects to allow for GC.

Overrides:
  `uninstallUI` in class `ComponentUI`
Parameters:
  `c` - the component from which this UI delegate is being removed; this argument is often ignored, but might be used if the UI object is stateless and shared by multiple components
See Also:
  `ComponentUI.installUI(javax.swing.JComponent)`, `JComponent.updateUI()`

#### installDefaults

    protected void installDefaults()

#### installComponents

    protected void installComponents()

#### uninstallComponents

    protected void uninstallComponents()

#### installListeners

    protected void installListeners()

#### installKeyboardActions

    protected void installKeyboardActions()

#### uninstallKeyboardActions

    protected void uninstallKeyboardActions()

#### uninstallListeners

    protected void uninstallListeners()

#### uninstallDefaults

    protected void uninstallDefaults()

#### createTrackListener

    protected BasicScrollBarUI.TrackListener createTrackListener()

#### createArrowButtonListener

    protected BasicScrollBarUI.ArrowButtonListener createArrowButtonListener()

#### createModelListener

    protected BasicScrollBarUI.ModelListener createModelListener()

#### createScrollListener

    protected BasicScrollBarUI.ScrollListener createScrollListener()

#### createPropertyChangeListener

    protected PropertyChangeListener createPropertyChangeListener()

#### setThumbRollover

    protected void setThumbRollover(boolean active)

Sets whether or not the mouse is currently over the thumb.

Parameters:
  `active` - True indicates the thumb is currently active.
Since:
  1.5

#### isThumbRollover

    public boolean isThumbRollover()

Returns true if the mouse is currently over the thumb.

Returns:
  true if the thumb is currently active
Since:
  1.5

#### paint

    public void paint(Graphics g,
                      JComponent c)

Description copied from class: `ComponentUI`
Paints the specified component appropriately for the look and feel. This method is invoked from the `ComponentUI.update` method when the specified component is being painted. Subclasses should override this method and use the specified `Graphics` object to render the content of the component.

Overrides:
  `paint` in class `ComponentUI`
Parameters:
  `g` - the `Graphics` context in which to paint
  `c` - the component being painted; this argument is often ignored, but might be used if the UI object is stateless and shared by multiple components
See Also:
  `ComponentUI.update(java.awt.Graphics, javax.swing.JComponent)`

#### getPreferredSize

    public Dimension getPreferredSize(JComponent c)

A vertical scrollbar's preferred width is the maximum of preferred widths of the (non `null`) 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.

The `preferredSize` is only computed once, subsequent calls to this method just return a cached size.

Overrides:
  `getPreferredSize` in class `ComponentUI`
Parameters:
  `c` - the `JScrollBar` that's delegating this method to us
Returns:
  the preferred size of a Basic JScrollBar
See Also:
  `getMaximumSize(javax.swing.JComponent)`, `ComponentUI.getMinimumSize(javax.swing.JComponent)`

#### getMaximumSize

    public Dimension getMaximumSize(JComponent c)

Description copied from class: `ComponentUI`
Returns the specified component's maximum size appropriate for the look and feel. If `null` is returned, the maximum size will be calculated by the component's layout manager instead (this is the preferred approach for any component with a specific layout manager installed). The default implementation of this method invokes `getPreferredSize` and returns that value.

Overrides:
  `getMaximumSize` in class `ComponentUI`
Parameters:
  `c` - The JScrollBar that's delegating this method to us.
Returns:
  new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
See Also:
  `ComponentUI.getMinimumSize(javax.swing.JComponent)`, `getPreferredSize(javax.swing.JComponent)`

#### createDecreaseButton

    protected JButton createDecreaseButton(int orientation)

#### createIncreaseButton

    protected JButton createIncreaseButton(int orientation)

#### paintDecreaseHighlight

    protected void paintDecreaseHighlight(Graphics g)

#### paintIncreaseHighlight

    protected void paintIncreaseHighlight(Graphics g)

#### paintTrack

    protected void paintTrack(Graphics g,
                              JComponent c,
                              Rectangle trackBounds)

#### paintThumb

    protected void paintThumb(Graphics g,
                              JComponent c,
                              Rectangle thumbBounds)

#### getMinimumThumbSize

    protected Dimension getMinimumThumbSize()

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.

Warning : the value returned by this method should not be be modified, it's a shared static constant.

Returns:
  The smallest acceptable size for the thumb.
See Also:
  `getMaximumThumbSize()`

#### getMaximumThumbSize

    protected Dimension getMaximumThumbSize()

Returns the largest acceptable size for the thumb. To create a fixed size thumb one make this method and `getMinimumThumbSize` return the same value.

Warning : the value returned by this method should not be be modified, it's a shared static constant.

Returns:
  The largest acceptable size for the thumb.
See Also:
  `getMinimumThumbSize()`

#### addLayoutComponent

    public void addLayoutComponent(String name,
                                   Component child)

Description copied from interface: `LayoutManager`
If the layout manager uses a per-component string, adds the component `comp` to the layout, associating it with the string specified by `name`.

Specified by:
  `addLayoutComponent` in interface `LayoutManager`
Parameters:
  `name` - the string to be associated with the component
  `child` - the component to be added

#### removeLayoutComponent

    public void removeLayoutComponent(Component child)

Description copied from interface: `LayoutManager`
Removes the specified component from the layout.

Specified by:
  `removeLayoutComponent` in interface `LayoutManager`
Parameters:
  `child` - the component to be removed

#### preferredLayoutSize

    public Dimension preferredLayoutSize(Container scrollbarContainer)

Description copied from interface: `LayoutManager`
Calculates the preferred size dimensions for the specified container, given the components it contains.

Specified by:
  `preferredLayoutSize` in interface `LayoutManager`
Parameters:
  `scrollbarContainer` - the container to be laid out
See Also:
  `LayoutManager.minimumLayoutSize(java.awt.Container)`

#### minimumLayoutSize

    public Dimension minimumLayoutSize(Container scrollbarContainer)

Description copied from interface: `LayoutManager`
Calculates the minimum size dimensions for the specified container, given the components it contains.

Specified by:
  `minimumLayoutSize` in interface `LayoutManager`
Parameters:
  `scrollbarContainer` - the component to be laid out
See Also:
  `LayoutManager.preferredLayoutSize(java.awt.Container)`

#### layoutVScrollbar

    protected void layoutVScrollbar(JScrollBar sb)

#### layoutHScrollbar

    protected void layoutHScrollbar(JScrollBar sb)

#### layoutContainer

    public void layoutContainer(Container scrollbarContainer)

Description copied from interface: `LayoutManager`
Lays out the specified container.

Specified by:
  `layoutContainer` in interface `LayoutManager`
Parameters:
  `scrollbarContainer` - the container to be laid out

#### setThumbBounds

    protected void setThumbBounds(int x,
                                  int y,
                                  int width,
                                  int height)

Set the bounds of the thumb and force a repaint that includes the old thumbBounds and the new one.

See Also:
  `getThumbBounds()`

#### getThumbBounds

    protected Rectangle getThumbBounds()

Return the current size/location of the thumb.

Warning : the value returned by this method should not be be modified, it's a reference to the actual rectangle, not a copy.

Returns:
  The current size/location of the thumb.
See Also:
  `setThumbBounds(int, int, int, int)`

#### getTrackBounds

    protected Rectangle getTrackBounds()

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).

Warning : the value returned by this method should not be be modified, it's a reference to the actual rectangle, not a copy.

Returns:
  the current bounds of the scrollbar track
See Also:
  `layoutContainer(java.awt.Container)`

#### scrollByBlock

    protected void scrollByBlock(int direction)

#### scrollByUnit

    protected void scrollByUnit(int direction)

#### getSupportsAbsolutePositioning

    public boolean getSupportsAbsolutePositioning()

Indicates whether the user can absolutely position the thumb with a mouse gesture (usually the middle mouse button).

Returns:
  true if a mouse gesture can absolutely position the thumb
Since:
  1.5