Also see:

getValue
setValue
serial:

Also see:

getMaximum
setMaximum
serial:

Also see:

getMinimum
setMinimum
serial:

Also see:

getVisibleAmount
setVisibleAmount
serial:

Also see:

getOrientation
setOrientation
serial:

Also see:

getLineIncrement
setLineIncrement
serial:

Also see:

getPageIncrement
setPageIncrement
serial:

Also see:

getValueIsAdjusting
setValueIsAdjusting
since: 1.4 -

 public Scrollbar() throws HeadlessException 
{
               
        /* ensure that the necessary native libraries are loaded */
        Toolkit.loadLibraries();
        if (!GraphicsEnvironment.isHeadless()) {
            initIDs();
        }
        this(VERTICAL, 0, 10, 0, 100);
}

Constructs a new vertical scroll bar. The default properties of the scroll bar are listed in the following table:

Property	Description	Default Value
orientation	indicates whether the scroll bar is vertical or horizontal	Scrollbar.VERTICAL
value	value which controls the location of the scroll bar's bubble	0
visible amount	visible amount of the scroll bar's range, typically represented by the size of the scroll bar's bubble	10
minimum	minimum value of the scroll bar	0
maximum	maximum value of the scroll bar	100
unit increment	amount the value changes when the Line Up or Line Down key is pressed, or when the end arrows of the scrollbar are clicked	1
block increment	amount the value changes when the Page Up or Page Down key is pressed, or when the scrollbar track is clicked on either side of the bubble	10

Throws:

HeadlessException - if GraphicsEnvironment.isHeadless() returns true.

Also see:

java.awt.GraphicsEnvironment#isHeadless
exception: HeadlessException - if GraphicsEnvironment.isHeadless() returns true.

 public Scrollbar(int orientation) throws HeadlessException 
{
        this(orientation, 0, 10, 0, 100);
}

Constructs a new scroll bar with the specified orientation.

The orientation argument must take one of the two values Scrollbar.HORIZONTAL, or Scrollbar.VERTICAL, indicating a horizontal or vertical scroll bar, respectively.

Parameters:

orientation - indicates the orientation of the scroll bar

Throws:

IllegalArgumentException - when an illegal value for the orientation argument is supplied

HeadlessException - if GraphicsEnvironment.isHeadless() returns true.

Also see:

java.awt.GraphicsEnvironment#isHeadless
exception: IllegalArgumentException - when an illegal value for the orientation argument is supplied

exception: HeadlessException - if GraphicsEnvironment.isHeadless() returns true.

 public Scrollbar(int orientation,
    int value,
    int visible,
    int minimum,
    int maximum) throws HeadlessException 
{
        GraphicsEnvironment.checkHeadless();
        switch (orientation) {
          case HORIZONTAL:
          case VERTICAL:
            this.orientation = orientation;
            break;
          default:
            throw new IllegalArgumentException("illegal scrollbar orientation");
        }
        setValues(value, visible, minimum, maximum);
}

Constructs a new scroll bar with the specified orientation, initial value, visible amount, and minimum and maximum values.

The orientation argument must take one of the two values Scrollbar.HORIZONTAL, or Scrollbar.VERTICAL, indicating a horizontal or vertical scroll bar, respectively.

The parameters supplied to this constructor are subject to the constraints described in #setValues(int, int, int, int) .

Parameters:

orientation - indicates the orientation of the scroll bar.

value - the initial value of the scroll bar

visible - the visible amount of the scroll bar, typically represented by the size of the bubble

minimum - the minimum value of the scroll bar

maximum - the maximum value of the scroll bar

Throws:

IllegalArgumentException - when an illegal value for the orientation argument is supplied

HeadlessException - if GraphicsEnvironment.isHeadless() returns true.

Also see:

setValues
java.awt.GraphicsEnvironment#isHeadless
exception: IllegalArgumentException - when an illegal value for the orientation argument is supplied

exception: HeadlessException - if GraphicsEnvironment.isHeadless() returns true.

 public synchronized  void addAdjustmentListener(AdjustmentListener l) 
{
        if (l == null) {
            return;
        }
        adjustmentListener = AWTEventMulticaster.add(adjustmentListener, l);
        newEventsOnly = true;
}

Adds the specified adjustment listener to receive instances of AdjustmentEvent from this scroll bar. If l is null, no exception is thrown and no action is performed.

Refer to AWT Threading Issues for details on AWT's threading model.

 public  void addNotify() 
{
        synchronized (getTreeLock()) {
            if (peer == null)
                peer = getToolkit().createScrollbar(this);
            super.addNotify();
        }
}

Creates the Scrollbar's peer. The peer allows you to modify the appearance of the Scrollbar without changing any of its functionality.

 String constructComponentName() 
{
        synchronized (Scrollbar.class) {
            return base + nameCounter++;
        }
}

Constructs a name for this component. Called by getName when the name is null.

 boolean eventEnabled(AWTEvent e) 
{
        if (e.id == AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED) {
            if ((eventMask & AWTEvent.ADJUSTMENT_EVENT_MASK) != 0 ||
                adjustmentListener != null) {
                return true;
            }
            return false;
        }
        return super.eventEnabled(e);
}

 public AccessibleContext getAccessibleContext() 
{
        if (accessibleContext == null) {
            accessibleContext = new AccessibleAWTScrollBar();
        }
        return accessibleContext;
}

Gets the AccessibleContext associated with this Scrollbar. For scrollbars, the AccessibleContext takes the form of an AccessibleAWTScrollBar. A new AccessibleAWTScrollBar instance is created if necessary.

 public synchronized AdjustmentListener[] getAdjustmentListeners() 
{
        return (AdjustmentListener[])(getListeners(AdjustmentListener.class));
}

Returns an array of all the adjustment listeners registered on this scrollbar.

 public int getBlockIncrement() 
{
        return getPageIncrement();
}

Gets the block increment of this scroll bar.

The block increment is the value that is added or subtracted when the user activates the block increment area of the scroll bar, generally through a mouse or keyboard gesture that the scroll bar receives as an adjustment event. The block increment must be greater than zero.

 public int getLineIncrement() 
{
        return lineIncrement;
}

 public T[] getListeners(Class listenerType) 
{
        EventListener l = null;
        if  (listenerType == AdjustmentListener.class) {
            l = adjustmentListener;
        } else {
            return super.getListeners(listenerType);
        }
        return AWTEventMulticaster.getListeners(l, listenerType);
}

Returns an array of all the objects currently registered as FooListeners upon this Scrollbar. FooListeners are registered using the addFooListener method.

You can specify the listenerType argument with a class literal, such as FooListener.class. For example, you can query a Scrollbar c for its mouse listeners with the following code:

MouseListener[] mls = (MouseListener[])(c.getListeners(MouseListener.class));

If no such listeners exist, this method returns an empty array.

 public int getMaximum() 
{
        return maximum;
}

Gets the maximum value of this scroll bar.

 public int getMinimum() 
{
        return minimum;
}

Gets the minimum value of this scroll bar.

 public int getOrientation() 
{
        return orientation;
}

Returns the orientation of this scroll bar.

 public int getPageIncrement() 
{
        return pageIncrement;
}

 public int getUnitIncrement() 
{
        return getLineIncrement();
}

Gets the unit increment for this scrollbar.

The unit increment is the value that is added or subtracted when the user activates the unit increment area of the scroll bar, generally through a mouse or keyboard gesture that the scroll bar receives as an adjustment event. The unit increment must be greater than zero.

 public int getValue() 
{
        return value;
}

Gets the current value of this scroll bar.

 public boolean getValueIsAdjusting() 
{
        return isAdjusting;
}

Returns true if the value is in the process of changing as a result of actions being taken by the user.

 public int getVisible() 
{
        return visibleAmount;
}

 public int getVisibleAmount() 
{
        return getVisible();
}

Gets the visible amount of this scroll bar.

When a scroll bar is used to select a range of values, the visible amount is used to represent the range of values that are currently visible. The size of the scroll bar's bubble (also called a thumb or scroll box), usually gives a visual representation of the relationship of the visible amount to the range of the scroll bar.

The scroll bar's bubble may not be displayed when it is not moveable (e.g. when it takes up the entire length of the scroll bar's track, or when the scroll bar is disabled). Whether the bubble is displayed or not will not affect the value returned by getVisibleAmount.

 protected String paramString() 
{
        return super.paramString() +
            ",val=" + value +
            ",vis=" + visibleAmount +
            ",min=" + minimum +
            ",max=" + maximum +
            ((orientation == VERTICAL) ? ",vert" : ",horz") +
            ",isAdjusting=" + isAdjusting;
}

Returns a string representing the state of this Scrollbar. This method is intended to be used only for debugging purposes, and the content and format of the returned string may vary between implementations. The returned string may be empty but may not be null.

 protected  void processAdjustmentEvent(AdjustmentEvent e) 
{
        AdjustmentListener listener = adjustmentListener;
        if (listener != null) {
            listener.adjustmentValueChanged(e);
        }
}

Processes adjustment events occurring on this scrollbar by dispatching them to any registered AdjustmentListener objects.

This method is not called unless adjustment events are enabled for this component. Adjustment events are enabled when one of the following occurs:

• An AdjustmentListener object is registered via addAdjustmentListener.
• Adjustment events are enabled via enableEvents.

Note that if the event parameter is null the behavior is unspecified and may result in an exception.

 protected  void processEvent(AWTEvent e) 
{
        if (e instanceof AdjustmentEvent) {
            processAdjustmentEvent((AdjustmentEvent)e);
            return;
        }
        super.processEvent(e);
}

Processes events on this scroll bar. If the event is an instance of AdjustmentEvent, it invokes the processAdjustmentEvent method. Otherwise, it invokes its superclass's processEvent method.

Note that if the event parameter is null the behavior is unspecified and may result in an exception.

 public synchronized  void removeAdjustmentListener(AdjustmentListener l) 
{
        if (l == null) {
            return;
        }
        adjustmentListener = AWTEventMulticaster.remove(adjustmentListener, l);
}

Removes the specified adjustment listener so that it no longer receives instances of AdjustmentEvent from this scroll bar. If l is null, no exception is thrown and no action is performed.

Refer to AWT Threading Issues for details on AWT's threading model.

 public  void setBlockIncrement(int v) 
{
        setPageIncrement(v);
}

Sets the block increment for this scroll bar.

The block increment is the value that is added or subtracted when the user activates the block increment area of the scroll bar, generally through a mouse or keyboard gesture that the scroll bar receives as an adjustment event. The block increment must be greater than zero. Attepts to set the block increment to a value lower than 1 will result in a value of 1 being set.

 public synchronized  void setLineIncrement(int v) 
{
        int tmp = (v <  1) ? 1 : v;
        if (lineIncrement == tmp) {
            return;
        }
        lineIncrement = tmp;
        ScrollbarPeer peer = (ScrollbarPeer)this.peer;
        if (peer != null) {
            peer.setLineIncrement(lineIncrement);
        }
}

 public  void setMaximum(int newMaximum) 
{
        // minimum is checked first in setValues, so we need to
        // enforce minimum and maximum checks here.
        if (newMaximum == Integer.MIN_VALUE) {
            newMaximum = Integer.MIN_VALUE + 1;
        }
        if (minimum  >= newMaximum) {
            minimum = newMaximum - 1;
        }
        // Use setValues so that a consistent policy relating
        // minimum, maximum, visible amount, and value is enforced.
        setValues(value, visibleAmount, minimum, newMaximum);
}

Sets the maximum value of this scroll bar.

When setMaximum is called, the maximum value is changed, and other values (including the minimum, the visible amount, and the current scroll bar value) are changed to be consistent with the new maximum.

Normally, a program should change a scroll bar's maximum value only by calling setValues. The setValues method simultaneously and synchronously sets the minimum, maximum, visible amount, and value properties of a scroll bar, so that they are mutually consistent.

Note that setting the maximum value to Integer.MIN_VALUE will result in the new maximum value being set to Integer.MIN_VALUE + 1.

 public  void setMinimum(int newMinimum) 
{
        // No checks are necessary in this method since minimum is
        // the first variable checked in the setValues function.
        // Use setValues so that a consistent policy relating
        // minimum, maximum, visible amount, and value is enforced.
        setValues(value, visibleAmount, newMinimum, maximum);
}

Sets the minimum value of this scroll bar.

When setMinimum is called, the minimum value is changed, and other values (including the maximum, the visible amount, and the current scroll bar value) are changed to be consistent with the new minimum.

Normally, a program should change a scroll bar's minimum value only by calling setValues. The setValues method simultaneously and synchronously sets the minimum, maximum, visible amount, and value properties of a scroll bar, so that they are mutually consistent.

Note that setting the minimum value to Integer.MAX_VALUE will result in the new minimum value being set to Integer.MAX_VALUE - 1.

 public  void setOrientation(int orientation) 
{
        synchronized (getTreeLock()) {
            if (orientation == this.orientation) {
                return;
            }
            switch (orientation) {
                case HORIZONTAL:
                case VERTICAL:
                    this.orientation = orientation;
                    break;
                default:
                    throw new IllegalArgumentException("illegal scrollbar orientation");
            }
            /* Create a new peer with the specified orientation. */
            if (peer != null) {
                removeNotify();
                addNotify();
                invalidate();
            }
        }
        if (accessibleContext != null) {
            accessibleContext.firePropertyChange(
                    AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
                    ((orientation == VERTICAL)
                     ? AccessibleState.HORIZONTAL : AccessibleState.VERTICAL),
                    ((orientation == VERTICAL)
                     ? AccessibleState.VERTICAL : AccessibleState.HORIZONTAL));
        }
}

Sets the orientation for this scroll bar.

 public synchronized  void setPageIncrement(int v) 
{
        int tmp = (v <  1) ? 1 : v;
        if (pageIncrement == tmp) {
            return;
        }
        pageIncrement = tmp;
        ScrollbarPeer peer = (ScrollbarPeer)this.peer;
        if (peer != null) {
            peer.setPageIncrement(pageIncrement);
        }
}

 public  void setUnitIncrement(int v) 
{
        setLineIncrement(v);
}

Sets the unit increment for this scroll bar.

The unit increment is the value that is added or subtracted when the user activates the unit increment area of the scroll bar, generally through a mouse or keyboard gesture that the scroll bar receives as an adjustment event. The unit increment must be greater than zero. Attepts to set the unit increment to a value lower than 1 will result in a value of 1 being set.

 public  void setValue(int newValue) 
{
        // Use setValues so that a consistent policy relating
        // minimum, maximum, visible amount, and value is enforced.
        setValues(newValue, visibleAmount, minimum, maximum);
}

Sets the value of this scroll bar to the specified value.

If the value supplied is less than the current minimum or greater than the current maximum - visibleAmount, then either minimum or maximum - visibleAmount is substituted, as appropriate.

Normally, a program should change a scroll bar's value only by calling setValues. The setValues method simultaneously and synchronously sets the minimum, maximum, visible amount, and value properties of a scroll bar, so that they are mutually consistent.

Calling this method does not fire an AdjustmentEvent.

 public  void setValueIsAdjusting(boolean b) 
{
        boolean oldValue;
        synchronized (this) {
            oldValue = isAdjusting;
            isAdjusting = b;
        }
        if ((oldValue != b) && (accessibleContext != null)) {
            accessibleContext.firePropertyChange(
                    AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
                    ((oldValue) ? AccessibleState.BUSY : null),
                    ((b) ? AccessibleState.BUSY : null));
        }
}

Sets the valueIsAdjusting property.

 public  void setValues(int value,
    int visible,
    int minimum,
    int maximum) 
{
        int oldValue;
        synchronized (this) {
            if (minimum == Integer.MAX_VALUE) {
                minimum = Integer.MAX_VALUE - 1;
            }
            if (maximum < = minimum) {
                maximum = minimum + 1;
            }
            long maxMinusMin = (long) maximum - (long) minimum;
            if (maxMinusMin  > Integer.MAX_VALUE) {
                maxMinusMin = Integer.MAX_VALUE;
                maximum = minimum + (int) maxMinusMin;
            }
            if (visible  > (int) maxMinusMin) {
                visible = (int) maxMinusMin;
            }
            if (visible <  1) {
                visible = 1;
            }
            if (value <  minimum) {
                value = minimum;
            }
            if (value  > maximum - visible) {
                value = maximum - visible;
            }
            oldValue = this.value;
            this.value = value;
            this.visibleAmount = visible;
            this.minimum = minimum;
            this.maximum = maximum;
            ScrollbarPeer peer = (ScrollbarPeer)this.peer;
            if (peer != null) {
                peer.setValues(value, visibleAmount, minimum, maximum);
            }
        }
        if ((oldValue != value) && (accessibleContext != null))  {
            accessibleContext.firePropertyChange(
                    AccessibleContext.ACCESSIBLE_VALUE_PROPERTY,
                    Integer.valueOf(oldValue),
                    Integer.valueOf(value));
        }
}

Sets the values of four properties for this scroll bar: value, visibleAmount, minimum, and maximum. If the values supplied for these properties are inconsistent or incorrect, they will be changed to ensure consistency.

This method simultaneously and synchronously sets the values of four scroll bar properties, assuring that the values of these properties are mutually consistent. It enforces the following constraints: maximum must be greater than minimum, maximum - minimum must not be greater than Integer.MAX_VALUE, visibleAmount must be greater than zero. visibleAmount must not be greater than maximum - minimum, value must not be less than minimum, and value must not be greater than maximum - visibleAmount

Calling this method does not fire an AdjustmentEvent.

 public  void setVisibleAmount(int newAmount) 
{
        // Use setValues so that a consistent policy relating
        // minimum, maximum, visible amount, and value is enforced.
        setValues(value, newAmount, minimum, maximum);
}

Sets the visible amount of this scroll bar.

When a scroll bar is used to select a range of values, the visible amount is used to represent the range of values that are currently visible. The size of the scroll bar's bubble (also called a thumb or scroll box), usually gives a visual representation of the relationship of the visible amount to the range of the scroll bar.

The scroll bar's bubble may not be displayed when it is not moveable (e.g. when it takes up the entire length of the scroll bar's track, or when the scroll bar is disabled). Whether the bubble is displayed or not will not affect the value returned by getVisibleAmount.

If the visible amount supplied is less than one or greater than the current maximum - minimum, then either one or maximum - minimum is substituted, as appropriate.

Normally, a program should change a scroll bar's value only by calling setValues. The setValues method simultaneously and synchronously sets the minimum, maximum, visible amount, and value properties of a scroll bar, so that they are mutually consistent.