0001 /*
0002 * Copyright 1995-2006 Sun Microsystems, Inc. All Rights Reserved.
0003 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
0004 *
0005 * This code is free software; you can redistribute it and/or modify it
0006 * under the terms of the GNU General Public License version 2 only, as
0007 * published by the Free Software Foundation. Sun designates this
0008 * particular file as subject to the "Classpath" exception as provided
0009 * by Sun in the LICENSE file that accompanied this code.
0010 *
0011 * This code is distributed in the hope that it will be useful, but WITHOUT
0012 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
0013 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
0014 * version 2 for more details (a copy is included in the LICENSE file that
0015 * accompanied this code).
0016 *
0017 * You should have received a copy of the GNU General Public License version
0018 * 2 along with this work; if not, write to the Free Software Foundation,
0019 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
0020 *
0021 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
0022 * CA 95054 USA or visit www.sun.com if you need additional information or
0023 * have any questions.
0024 */
0025 package java.awt;
0026
0027 import java.awt.peer.ScrollbarPeer;
0028 import java.awt.event.*;
0029 import java.util.EventListener;
0030 import java.io.ObjectOutputStream;
0031 import java.io.ObjectInputStream;
0032 import java.io.IOException;
0033 import javax.accessibility.*;
0034
0035 /**
0036 * The <code>Scrollbar</code> class embodies a scroll bar, a
0037 * familiar user-interface object. A scroll bar provides a
0038 * convenient means for allowing a user to select from a
0039 * range of values. The following three vertical
0040 * scroll bars could be used as slider controls to pick
0041 * the red, green, and blue components of a color:
0042 * <p>
0043 * <img src="doc-files/Scrollbar-1.gif" alt="Image shows 3 vertical sliders, side-by-side."
0044 * ALIGN=center HSPACE=10 VSPACE=7>
0045 * <p>
0046 * Each scroll bar in this example could be created with
0047 * code similar to the following:
0048 * <p>
0049 * <hr><blockquote><pre>
0050 * redSlider=new Scrollbar(Scrollbar.VERTICAL, 0, 1, 0, 255);
0051 * add(redSlider);
0052 * </pre></blockquote><hr>
0053 * <p>
0054 * Alternatively, a scroll bar can represent a range of values. For
0055 * example, if a scroll bar is used for scrolling through text, the
0056 * width of the "bubble" (also called the "thumb" or "scroll box")
0057 * can be used to represent the amount of text that is visible.
0058 * Here is an example of a scroll bar that represents a range:
0059 * <p>
0060 * <img src="doc-files/Scrollbar-2.gif"
0061 * alt="Image shows horizontal slider with starting range of 0 and ending range of 300. The slider thumb is labeled 60."
0062 * ALIGN=center HSPACE=10 VSPACE=7>
0063 * <p>
0064 * The value range represented by the bubble in this example
0065 * is the <em>visible amount</em>. The horizontal scroll bar
0066 * in this example could be created with code like the following:
0067 * <p>
0068 * <hr><blockquote><pre>
0069 * ranger = new Scrollbar(Scrollbar.HORIZONTAL, 0, 60, 0, 300);
0070 * add(ranger);
0071 * </pre></blockquote><hr>
0072 * <p>
0073 * Note that the actual maximum value of the scroll bar is the
0074 * <code>maximum</code> minus the <code>visible amount</code>.
0075 * In the previous example, because the <code>maximum</code> is
0076 * 300 and the <code>visible amount</code> is 60, the actual maximum
0077 * value is 240. The range of the scrollbar track is 0 - 300.
0078 * The left side of the bubble indicates the value of the
0079 * scroll bar.
0080 * <p>
0081 * Normally, the user changes the value of the scroll bar by
0082 * making a gesture with the mouse. For example, the user can
0083 * drag the scroll bar's bubble up and down, or click in the
0084 * scroll bar's unit increment or block increment areas. Keyboard
0085 * gestures can also be mapped to the scroll bar. By convention,
0086 * the <b>Page Up</b> and <b>Page Down</b>
0087 * keys are equivalent to clicking in the scroll bar's block
0088 * increment and block decrement areas.
0089 * <p>
0090 * When the user changes the value of the scroll bar, the scroll bar
0091 * receives an instance of <code>AdjustmentEvent</code>.
0092 * The scroll bar processes this event, passing it along to
0093 * any registered listeners.
0094 * <p>
0095 * Any object that wishes to be notified of changes to the
0096 * scroll bar's value should implement
0097 * <code>AdjustmentListener</code>, an interface defined in
0098 * the package <code>java.awt.event</code>.
0099 * Listeners can be added and removed dynamically by calling
0100 * the methods <code>addAdjustmentListener</code> and
0101 * <code>removeAdjustmentListener</code>.
0102 * <p>
0103 * The <code>AdjustmentEvent</code> class defines five types
0104 * of adjustment event, listed here:
0105 * <p>
0106 * <ul>
0107 * <li><code>AdjustmentEvent.TRACK</code> is sent out when the
0108 * user drags the scroll bar's bubble.
0109 * <li><code>AdjustmentEvent.UNIT_INCREMENT</code> is sent out
0110 * when the user clicks in the left arrow of a horizontal scroll
0111 * bar, or the top arrow of a vertical scroll bar, or makes the
0112 * equivalent gesture from the keyboard.
0113 * <li><code>AdjustmentEvent.UNIT_DECREMENT</code> is sent out
0114 * when the user clicks in the right arrow of a horizontal scroll
0115 * bar, or the bottom arrow of a vertical scroll bar, or makes the
0116 * equivalent gesture from the keyboard.
0117 * <li><code>AdjustmentEvent.BLOCK_INCREMENT</code> is sent out
0118 * when the user clicks in the track, to the left of the bubble
0119 * on a horizontal scroll bar, or above the bubble on a vertical
0120 * scroll bar. By convention, the <b>Page Up</b>
0121 * key is equivalent, if the user is using a keyboard that
0122 * defines a <b>Page Up</b> key.
0123 * <li><code>AdjustmentEvent.BLOCK_DECREMENT</code> is sent out
0124 * when the user clicks in the track, to the right of the bubble
0125 * on a horizontal scroll bar, or below the bubble on a vertical
0126 * scroll bar. By convention, the <b>Page Down</b>
0127 * key is equivalent, if the user is using a keyboard that
0128 * defines a <b>Page Down</b> key.
0129 * </ul>
0130 * <p>
0131 * The JDK 1.0 event system is supported for backwards
0132 * compatibility, but its use with newer versions of the platform is
0133 * discouraged. The five types of adjustment events introduced
0134 * with JDK 1.1 correspond to the five event types
0135 * that are associated with scroll bars in previous platform versions.
0136 * The following list gives the adjustment event type,
0137 * and the corresponding JDK 1.0 event type it replaces.
0138 * <p>
0139 * <ul>
0140 * <li><code>AdjustmentEvent.TRACK</code> replaces
0141 * <code>Event.SCROLL_ABSOLUTE</code>
0142 * <li><code>AdjustmentEvent.UNIT_INCREMENT</code> replaces
0143 * <code>Event.SCROLL_LINE_UP</code>
0144 * <li><code>AdjustmentEvent.UNIT_DECREMENT</code> replaces
0145 * <code>Event.SCROLL_LINE_DOWN</code>
0146 * <li><code>AdjustmentEvent.BLOCK_INCREMENT</code> replaces
0147 * <code>Event.SCROLL_PAGE_UP</code>
0148 * <li><code>AdjustmentEvent.BLOCK_DECREMENT</code> replaces
0149 * <code>Event.SCROLL_PAGE_DOWN</code>
0150 * </ul>
0151 * <p>
0152 * <b>Note</b>: We recommend using a <code>Scrollbar</code>
0153 * for value selection only. If you want to implement
0154 * a scrollable component inside a container, we recommend you use
0155 * a {@link ScrollPane ScrollPane}. If you use a
0156 * <code>Scrollbar</code> for this purpose, you are likely to
0157 * encounter issues with painting, key handling, sizing and
0158 * positioning.
0159 *
0160 * @version 1.119, 05/05/07
0161 * @author Sami Shaio
0162 * @see java.awt.event.AdjustmentEvent
0163 * @see java.awt.event.AdjustmentListener
0164 * @since JDK1.0
0165 */
0166 public class Scrollbar extends Component implements Adjustable,
0167 Accessible {
0168
0169 /**
0170 * A constant that indicates a horizontal scroll bar.
0171 */
0172 public static final int HORIZONTAL = 0;
0173
0174 /**
0175 * A constant that indicates a vertical scroll bar.
0176 */
0177 public static final int VERTICAL = 1;
0178
0179 /**
0180 * The value of the <code>Scrollbar</code>.
0181 * This property must be greater than or equal to <code>minimum</code>
0182 * and less than or equal to
0183 * <code>maximum - visibleAmount</code>
0184 *
0185 * @serial
0186 * @see #getValue
0187 * @see #setValue
0188 */
0189 int value;
0190
0191 /**
0192 * The maximum value of the <code>Scrollbar</code>.
0193 * This value must be greater than the <code>minimum</code>
0194 * value.<br>
0195 *
0196 * @serial
0197 * @see #getMaximum
0198 * @see #setMaximum
0199 */
0200 int maximum;
0201
0202 /**
0203 * The minimum value of the <code>Scrollbar</code>.
0204 * This value must be less than the <code>maximum</code>
0205 * value.<br>
0206 *
0207 * @serial
0208 * @see #getMinimum
0209 * @see #setMinimum
0210 */
0211 int minimum;
0212
0213 /**
0214 * The size of the <code>Scrollbar</code>'s bubble.
0215 * When a scroll bar is used to select a range of values,
0216 * the visibleAmount represents the size of this range.
0217 * This is visually indicated by the size of the bubble.
0218 *
0219 * @serial
0220 * @see #getVisibleAmount
0221 * @see #setVisibleAmount
0222 */
0223 int visibleAmount;
0224
0225 /**
0226 * The <code>Scrollbar</code>'s orientation--being either horizontal
0227 * or vertical.
0228 * This value should be specified when the scrollbar is created.<BR>
0229 * orientation can be either : <code>VERTICAL</code> or
0230 * <code>HORIZONTAL</code> only.
0231 *
0232 * @serial
0233 * @see #getOrientation
0234 * @see #setOrientation
0235 */
0236 int orientation;
0237
0238 /**
0239 * The amount by which the scrollbar value will change when going
0240 * up or down by a line.
0241 * This value must be greater than zero.
0242 *
0243 * @serial
0244 * @see #getLineIncrement
0245 * @see #setLineIncrement
0246 */
0247 int lineIncrement = 1;
0248
0249 /**
0250 * The amount by which the scrollbar value will change when going
0251 * up or down by a page.
0252 * This value must be greater than zero.
0253 *
0254 * @serial
0255 * @see #getPageIncrement
0256 * @see #setPageIncrement
0257 */
0258 int pageIncrement = 10;
0259
0260 /**
0261 * The adjusting status of the <code>Scrollbar</code>.
0262 * True if the value is in the process of changing as a result of
0263 * actions being taken by the user.
0264 *
0265 * @see #getValueIsAdjusting
0266 * @see #setValueIsAdjusting
0267 * @since 1.4
0268 */
0269 transient boolean isAdjusting;
0270
0271 transient AdjustmentListener adjustmentListener;
0272
0273 private static final String base = "scrollbar";
0274 private static int nameCounter = 0;
0275
0276 /*
0277 * JDK 1.1 serialVersionUID
0278 */
0279 private static final long serialVersionUID = 8451667562882310543L;
0280
0281 /**
0282 * Initialize JNI field and method IDs.
0283 */
0284 private static native void initIDs();
0285
0286 static {
0287 /* ensure that the necessary native libraries are loaded */
0288 Toolkit.loadLibraries();
0289 if (!GraphicsEnvironment.isHeadless()) {
0290 initIDs();
0291 }
0292 }
0293
0294 /**
0295 * Constructs a new vertical scroll bar.
0296 * The default properties of the scroll bar are listed in
0297 * the following table:
0298 * <p> </p>
0299 * <table border=1 summary="Scrollbar default properties">
0300 * <tr>
0301 * <th>Property</th>
0302 * <th>Description</th>
0303 * <th>Default Value</th>
0304 * </tr>
0305 * <tr>
0306 * <td>orientation</td>
0307 * <td>indicates whether the scroll bar is vertical
0308 * <br>or horizontal</td>
0309 * <td><code>Scrollbar.VERTICAL</code></td>
0310 * </tr>
0311 * <tr>
0312 * <td>value</td>
0313 * <td>value which controls the location
0314 * <br>of the scroll bar's bubble</td>
0315 * <td>0</td>
0316 * </tr>
0317 * <tr>
0318 * <td>visible amount</td>
0319 * <td>visible amount of the scroll bar's range,
0320 * <br>typically represented by the size of the
0321 * <br>scroll bar's bubble</td>
0322 * <td>10</td>
0323 * </tr>
0324 * <tr>
0325 * <td>minimum</td>
0326 * <td>minimum value of the scroll bar</td>
0327 * <td>0</td>
0328 * </tr>
0329 * <tr>
0330 * <td>maximum</td>
0331 * <td>maximum value of the scroll bar</td>
0332 * <td>100</td>
0333 * </tr>
0334 * <tr>
0335 * <td>unit increment</td>
0336 * <td>amount the value changes when the
0337 * <br>Line Up or Line Down key is pressed,
0338 * <br>or when the end arrows of the scrollbar
0339 * <br>are clicked </td>
0340 * <td>1</td>
0341 * </tr>
0342 * <tr>
0343 * <td>block increment</td>
0344 * <td>amount the value changes when the
0345 * <br>Page Up or Page Down key is pressed,
0346 * <br>or when the scrollbar track is clicked
0347 * <br>on either side of the bubble </td>
0348 * <td>10</td>
0349 * </tr>
0350 * </table>
0351 *
0352 * @exception HeadlessException if GraphicsEnvironment.isHeadless()
0353 * returns true.
0354 * @see java.awt.GraphicsEnvironment#isHeadless
0355 */
0356 public Scrollbar() throws HeadlessException {
0357 this (VERTICAL, 0, 10, 0, 100);
0358 }
0359
0360 /**
0361 * Constructs a new scroll bar with the specified orientation.
0362 * <p>
0363 * The <code>orientation</code> argument must take one of the two
0364 * values <code>Scrollbar.HORIZONTAL</code>,
0365 * or <code>Scrollbar.VERTICAL</code>,
0366 * indicating a horizontal or vertical scroll bar, respectively.
0367 *
0368 * @param orientation indicates the orientation of the scroll bar
0369 * @exception IllegalArgumentException when an illegal value for
0370 * the <code>orientation</code> argument is supplied
0371 * @exception HeadlessException if GraphicsEnvironment.isHeadless()
0372 * returns true.
0373 * @see java.awt.GraphicsEnvironment#isHeadless
0374 */
0375 public Scrollbar(int orientation) throws HeadlessException {
0376 this (orientation, 0, 10, 0, 100);
0377 }
0378
0379 /**
0380 * Constructs a new scroll bar with the specified orientation,
0381 * initial value, visible amount, and minimum and maximum values.
0382 * <p>
0383 * The <code>orientation</code> argument must take one of the two
0384 * values <code>Scrollbar.HORIZONTAL</code>,
0385 * or <code>Scrollbar.VERTICAL</code>,
0386 * indicating a horizontal or vertical scroll bar, respectively.
0387 * <p>
0388 * The parameters supplied to this constructor are subject to the
0389 * constraints described in {@link #setValues(int, int, int, int)}.
0390 *
0391 * @param orientation indicates the orientation of the scroll bar.
0392 * @param value the initial value of the scroll bar
0393 * @param visible the visible amount of the scroll bar, typically
0394 * represented by the size of the bubble
0395 * @param minimum the minimum value of the scroll bar
0396 * @param maximum the maximum value of the scroll bar
0397 * @exception IllegalArgumentException when an illegal value for
0398 * the <code>orientation</code> argument is supplied
0399 * @exception HeadlessException if GraphicsEnvironment.isHeadless()
0400 * returns true.
0401 * @see #setValues
0402 * @see java.awt.GraphicsEnvironment#isHeadless
0403 */
0404 public Scrollbar(int orientation, int value, int visible,
0405 int minimum, int maximum) throws HeadlessException {
0406 GraphicsEnvironment.checkHeadless();
0407 switch (orientation) {
0408 case HORIZONTAL:
0409 case VERTICAL:
0410 this .orientation = orientation;
0411 break;
0412 default:
0413 throw new IllegalArgumentException(
0414 "illegal scrollbar orientation");
0415 }
0416 setValues(value, visible, minimum, maximum);
0417 }
0418
0419 /**
0420 * Constructs a name for this component. Called by <code>getName</code>
0421 * when the name is <code>null</code>.
0422 */
0423 String constructComponentName() {
0424 synchronized (Scrollbar.class) {
0425 return base + nameCounter++;
0426 }
0427 }
0428
0429 /**
0430 * Creates the <code>Scrollbar</code>'s peer. The peer allows you to modify
0431 * the appearance of the <code>Scrollbar</code> without changing any of its
0432 * functionality.
0433 */
0434 public void addNotify() {
0435 synchronized (getTreeLock()) {
0436 if (peer == null)
0437 peer = getToolkit().createScrollbar(this );
0438 super .addNotify();
0439 }
0440 }
0441
0442 /**
0443 * Returns the orientation of this scroll bar.
0444 *
0445 * @return the orientation of this scroll bar, either
0446 * <code>Scrollbar.HORIZONTAL</code> or
0447 * <code>Scrollbar.VERTICAL</code>
0448 * @see java.awt.Scrollbar#setOrientation
0449 */
0450 public int getOrientation() {
0451 return orientation;
0452 }
0453
0454 /**
0455 * Sets the orientation for this scroll bar.
0456 *
0457 * @param orientation the orientation of this scroll bar, either
0458 * <code>Scrollbar.HORIZONTAL</code> or
0459 * <code>Scrollbar.VERTICAL</code>
0460 * @see java.awt.Scrollbar#getOrientation
0461 * @exception IllegalArgumentException if the value supplied
0462 * for <code>orientation</code> is not a
0463 * legal value
0464 * @since JDK1.1
0465 */
0466 public void setOrientation(int orientation) {
0467 synchronized (getTreeLock()) {
0468 if (orientation == this .orientation) {
0469 return;
0470 }
0471 switch (orientation) {
0472 case HORIZONTAL:
0473 case VERTICAL:
0474 this .orientation = orientation;
0475 break;
0476 default:
0477 throw new IllegalArgumentException(
0478 "illegal scrollbar orientation");
0479 }
0480 /* Create a new peer with the specified orientation. */
0481 if (peer != null) {
0482 removeNotify();
0483 addNotify();
0484 invalidate();
0485 }
0486 }
0487 if (accessibleContext != null) {
0488 accessibleContext
0489 .firePropertyChange(
0490 AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
0491 ((orientation == VERTICAL) ? AccessibleState.HORIZONTAL
0492 : AccessibleState.VERTICAL),
0493 ((orientation == VERTICAL) ? AccessibleState.VERTICAL
0494 : AccessibleState.HORIZONTAL));
0495 }
0496 }
0497
0498 /**
0499 * Gets the current value of this scroll bar.
0500 *
0501 * @return the current value of this scroll bar
0502 * @see java.awt.Scrollbar#getMinimum
0503 * @see java.awt.Scrollbar#getMaximum
0504 */
0505 public int getValue() {
0506 return value;
0507 }
0508
0509 /**
0510 * Sets the value of this scroll bar to the specified value.
0511 * <p>
0512 * If the value supplied is less than the current <code>minimum</code>
0513 * or greater than the current <code>maximum - visibleAmount</code>,
0514 * then either <code>minimum</code> or <code>maximum - visibleAmount</code>
0515 * is substituted, as appropriate.
0516 * <p>
0517 * Normally, a program should change a scroll bar's
0518 * value only by calling <code>setValues</code>.
0519 * The <code>setValues</code> method simultaneously
0520 * and synchronously sets the minimum, maximum, visible amount,
0521 * and value properties of a scroll bar, so that they are
0522 * mutually consistent.
0523 * <p>
0524 * Calling this method does not fire an
0525 * <code>AdjustmentEvent</code>.
0526 *
0527 * @param newValue the new value of the scroll bar
0528 * @see java.awt.Scrollbar#setValues
0529 * @see java.awt.Scrollbar#getValue
0530 * @see java.awt.Scrollbar#getMinimum
0531 * @see java.awt.Scrollbar#getMaximum
0532 */
0533 public void setValue(int newValue) {
0534 // Use setValues so that a consistent policy relating
0535 // minimum, maximum, visible amount, and value is enforced.
0536 setValues(newValue, visibleAmount, minimum, maximum);
0537 }
0538
0539 /**
0540 * Gets the minimum value of this scroll bar.
0541 *
0542 * @return the minimum value of this scroll bar
0543 * @see java.awt.Scrollbar#getValue
0544 * @see java.awt.Scrollbar#getMaximum
0545 */
0546 public int getMinimum() {
0547 return minimum;
0548 }
0549
0550 /**
0551 * Sets the minimum value of this scroll bar.
0552 * <p>
0553 * When <code>setMinimum</code> is called, the minimum value
0554 * is changed, and other values (including the maximum, the
0555 * visible amount, and the current scroll bar value)
0556 * are changed to be consistent with the new minimum.
0557 * <p>
0558 * Normally, a program should change a scroll bar's minimum
0559 * value only by calling <code>setValues</code>.
0560 * The <code>setValues</code> method simultaneously
0561 * and synchronously sets the minimum, maximum, visible amount,
0562 * and value properties of a scroll bar, so that they are
0563 * mutually consistent.
0564 * <p>
0565 * Note that setting the minimum value to <code>Integer.MAX_VALUE</code>
0566 * will result in the new minimum value being set to
0567 * <code>Integer.MAX_VALUE - 1</code>.
0568 *
0569 * @param newMinimum the new minimum value for this scroll bar
0570 * @see java.awt.Scrollbar#setValues
0571 * @see java.awt.Scrollbar#setMaximum
0572 * @since JDK1.1
0573 */
0574 public void setMinimum(int newMinimum) {
0575 // No checks are necessary in this method since minimum is
0576 // the first variable checked in the setValues function.
0577
0578 // Use setValues so that a consistent policy relating
0579 // minimum, maximum, visible amount, and value is enforced.
0580 setValues(value, visibleAmount, newMinimum, maximum);
0581 }
0582
0583 /**
0584 * Gets the maximum value of this scroll bar.
0585 *
0586 * @return the maximum value of this scroll bar
0587 * @see java.awt.Scrollbar#getValue
0588 * @see java.awt.Scrollbar#getMinimum
0589 */
0590 public int getMaximum() {
0591 return maximum;
0592 }
0593
0594 /**
0595 * Sets the maximum value of this scroll bar.
0596 * <p>
0597 * When <code>setMaximum</code> is called, the maximum value
0598 * is changed, and other values (including the minimum, the
0599 * visible amount, and the current scroll bar value)
0600 * are changed to be consistent with the new maximum.
0601 * <p>
0602 * Normally, a program should change a scroll bar's maximum
0603 * value only by calling <code>setValues</code>.
0604 * The <code>setValues</code> method simultaneously
0605 * and synchronously sets the minimum, maximum, visible amount,
0606 * and value properties of a scroll bar, so that they are
0607 * mutually consistent.
0608 * <p>
0609 * Note that setting the maximum value to <code>Integer.MIN_VALUE</code>
0610 * will result in the new maximum value being set to
0611 * <code>Integer.MIN_VALUE + 1</code>.
0612 *
0613 * @param newMaximum the new maximum value
0614 * for this scroll bar
0615 * @see java.awt.Scrollbar#setValues
0616 * @see java.awt.Scrollbar#setMinimum
0617 * @since JDK1.1
0618 */
0619 public void setMaximum(int newMaximum) {
0620 // minimum is checked first in setValues, so we need to
0621 // enforce minimum and maximum checks here.
0622 if (newMaximum == Integer.MIN_VALUE) {
0623 newMaximum = Integer.MIN_VALUE + 1;
0624 }
0625
0626 if (minimum >= newMaximum) {
0627 minimum = newMaximum - 1;
0628 }
0629
0630 // Use setValues so that a consistent policy relating
0631 // minimum, maximum, visible amount, and value is enforced.
0632 setValues(value, visibleAmount, minimum, newMaximum);
0633 }
0634
0635 /**
0636 * Gets the visible amount of this scroll bar.
0637 * <p>
0638 * When a scroll bar is used to select a range of values,
0639 * the visible amount is used to represent the range of values
0640 * that are currently visible. The size of the scroll bar's
0641 * bubble (also called a thumb or scroll box), usually gives a
0642 * visual representation of the relationship of the visible
0643 * amount to the range of the scroll bar.
0644 * <p>
0645 * The scroll bar's bubble may not be displayed when it is not
0646 * moveable (e.g. when it takes up the entire length of the
0647 * scroll bar's track, or when the scroll bar is disabled).
0648 * Whether the bubble is displayed or not will not affect
0649 * the value returned by <code>getVisibleAmount</code>.
0650 *
0651 * @return the visible amount of this scroll bar
0652 * @see java.awt.Scrollbar#setVisibleAmount
0653 * @since JDK1.1
0654 */
0655 public int getVisibleAmount() {
0656 return getVisible();
0657 }
0658
0659 /**
0660 * @deprecated As of JDK version 1.1,
0661 * replaced by <code>getVisibleAmount()</code>.
0662 */
0663 @Deprecated
0664 public int getVisible() {
0665 return visibleAmount;
0666 }
0667
0668 /**
0669 * Sets the visible amount of this scroll bar.
0670 * <p>
0671 * When a scroll bar is used to select a range of values,
0672 * the visible amount is used to represent the range of values
0673 * that are currently visible. The size of the scroll bar's
0674 * bubble (also called a thumb or scroll box), usually gives a
0675 * visual representation of the relationship of the visible
0676 * amount to the range of the scroll bar.
0677 * <p>
0678 * The scroll bar's bubble may not be displayed when it is not
0679 * moveable (e.g. when it takes up the entire length of the
0680 * scroll bar's track, or when the scroll bar is disabled).
0681 * Whether the bubble is displayed or not will not affect
0682 * the value returned by <code>getVisibleAmount</code>.
0683 * <p>
0684 * If the visible amount supplied is less than <code>one</code>
0685 * or greater than the current <code>maximum - minimum</code>,
0686 * then either <code>one</code> or <code>maximum - minimum</code>
0687 * is substituted, as appropriate.
0688 * <p>
0689 * Normally, a program should change a scroll bar's
0690 * value only by calling <code>setValues</code>.
0691 * The <code>setValues</code> method simultaneously
0692 * and synchronously sets the minimum, maximum, visible amount,
0693 * and value properties of a scroll bar, so that they are
0694 * mutually consistent.
0695 *
0696 * @param newAmount the new visible amount
0697 * @see java.awt.Scrollbar#getVisibleAmount
0698 * @see java.awt.Scrollbar#setValues
0699 * @since JDK1.1
0700 */
0701 public void setVisibleAmount(int newAmount) {
0702 // Use setValues so that a consistent policy relating
0703 // minimum, maximum, visible amount, and value is enforced.
0704 setValues(value, newAmount, minimum, maximum);
0705 }
0706
0707 /**
0708 * Sets the unit increment for this scroll bar.
0709 * <p>
0710 * The unit increment is the value that is added or subtracted
0711 * when the user activates the unit increment area of the
0712 * scroll bar, generally through a mouse or keyboard gesture
0713 * that the scroll bar receives as an adjustment event.
0714 * The unit increment must be greater than zero.
0715 * Attepts to set the unit increment to a value lower than 1
0716 * will result in a value of 1 being set.
0717 *
0718 * @param v the amount by which to increment or decrement
0719 * the scroll bar's value
0720 * @see java.awt.Scrollbar#getUnitIncrement
0721 * @since JDK1.1
0722 */
0723 public void setUnitIncrement(int v) {
0724 setLineIncrement(v);
0725 }
0726
0727 /**
0728 * @deprecated As of JDK version 1.1,
0729 * replaced by <code>setUnitIncrement(int)</code>.
0730 */
0731 @Deprecated
0732 public synchronized void setLineIncrement(int v) {
0733 int tmp = (v < 1) ? 1 : v;
0734
0735 if (lineIncrement == tmp) {
0736 return;
0737 }
0738 lineIncrement = tmp;
0739
0740 ScrollbarPeer peer = (ScrollbarPeer) this .peer;
0741 if (peer != null) {
0742 peer.setLineIncrement(lineIncrement);
0743 }
0744 }
0745
0746 /**
0747 * Gets the unit increment for this scrollbar.
0748 * <p>
0749 * The unit increment is the value that is added or subtracted
0750 * when the user activates the unit increment area of the
0751 * scroll bar, generally through a mouse or keyboard gesture
0752 * that the scroll bar receives as an adjustment event.
0753 * The unit increment must be greater than zero.
0754 *
0755 * @return the unit increment of this scroll bar
0756 * @see java.awt.Scrollbar#setUnitIncrement
0757 * @since JDK1.1
0758 */
0759 public int getUnitIncrement() {
0760 return getLineIncrement();
0761 }
0762
0763 /**
0764 * @deprecated As of JDK version 1.1,
0765 * replaced by <code>getUnitIncrement()</code>.
0766 */
0767 @Deprecated
0768 public int getLineIncrement() {
0769 return lineIncrement;
0770 }
0771
0772 /**
0773 * Sets the block increment for this scroll bar.
0774 * <p>
0775 * The block increment is the value that is added or subtracted
0776 * when the user activates the block increment area of the
0777 * scroll bar, generally through a mouse or keyboard gesture
0778 * that the scroll bar receives as an adjustment event.
0779 * The block increment must be greater than zero.
0780 * Attepts to set the block increment to a value lower than 1
0781 * will result in a value of 1 being set.
0782 *
0783 * @param v the amount by which to increment or decrement
0784 * the scroll bar's value
0785 * @see java.awt.Scrollbar#getBlockIncrement
0786 * @since JDK1.1
0787 */
0788 public void setBlockIncrement(int v) {
0789 setPageIncrement(v);
0790 }
0791
0792 /**
0793 * @deprecated As of JDK version 1.1,
0794 * replaced by <code>setBlockIncrement()</code>.
0795 */
0796 @Deprecated
0797 public synchronized void setPageIncrement(int v) {
0798 int tmp = (v < 1) ? 1 : v;
0799
0800 if (pageIncrement == tmp) {
0801 return;
0802 }
0803 pageIncrement = tmp;
0804
0805 ScrollbarPeer peer = (ScrollbarPeer) this .peer;
0806 if (peer != null) {
0807 peer.setPageIncrement(pageIncrement);
0808 }
0809 }
0810
0811 /**
0812 * Gets the block increment of this scroll bar.
0813 * <p>
0814 * The block increment is the value that is added or subtracted
0815 * when the user activates the block increment area of the
0816 * scroll bar, generally through a mouse or keyboard gesture
0817 * that the scroll bar receives as an adjustment event.
0818 * The block increment must be greater than zero.
0819 *
0820 * @return the block increment of this scroll bar
0821 * @see java.awt.Scrollbar#setBlockIncrement
0822 * @since JDK1.1
0823 */
0824 public int getBlockIncrement() {
0825 return getPageIncrement();
0826 }
0827
0828 /**
0829 * @deprecated As of JDK version 1.1,
0830 * replaced by <code>getBlockIncrement()</code>.
0831 */
0832 @Deprecated
0833 public int getPageIncrement() {
0834 return pageIncrement;
0835 }
0836
0837 /**
0838 * Sets the values of four properties for this scroll bar:
0839 * <code>value</code>, <code>visibleAmount</code>,
0840 * <code>minimum</code>, and <code>maximum</code>.
0841 * If the values supplied for these properties are inconsistent
0842 * or incorrect, they will be changed to ensure consistency.
0843 * <p>
0844 * This method simultaneously and synchronously sets the values
0845 * of four scroll bar properties, assuring that the values of
0846 * these properties are mutually consistent. It enforces the
0847 * following constraints:
0848 * <code>maximum</code> must be greater than <code>minimum</code>,
0849 * <code>maximum - minimum</code> must not be greater
0850 * than <code>Integer.MAX_VALUE</code>,
0851 * <code>visibleAmount</code> must be greater than zero.
0852 * <code>visibleAmount</code> must not be greater than
0853 * <code>maximum - minimum</code>,
0854 * <code>value</code> must not be less than <code>minimum</code>,
0855 * and <code>value</code> must not be greater than
0856 * <code>maximum - visibleAmount</code>
0857 * <p>
0858 * Calling this method does not fire an
0859 * <code>AdjustmentEvent</code>.
0860 *
0861 * @param value is the position in the current window
0862 * @param visible is the visible amount of the scroll bar
0863 * @param minimum is the minimum value of the scroll bar
0864 * @param maximum is the maximum value of the scroll bar
0865 * @see #setMinimum
0866 * @see #setMaximum
0867 * @see #setVisibleAmount
0868 * @see #setValue
0869 */
0870 public void setValues(int value, int visible, int minimum,
0871 int maximum) {
0872 int oldValue;
0873 synchronized (this ) {
0874 if (minimum == Integer.MAX_VALUE) {
0875 minimum = Integer.MAX_VALUE - 1;
0876 }
0877 if (maximum <= minimum) {
0878 maximum = minimum + 1;
0879 }
0880
0881 long maxMinusMin = (long) maximum - (long) minimum;
0882 if (maxMinusMin > Integer.MAX_VALUE) {
0883 maxMinusMin = Integer.MAX_VALUE;
0884 maximum = minimum + (int) maxMinusMin;
0885 }
0886 if (visible > (int) maxMinusMin) {
0887 visible = (int) maxMinusMin;
0888 }
0889 if (visible < 1) {
0890 visible = 1;
0891 }
0892
0893 if (value < minimum) {
0894 value = minimum;
0895 }
0896 if (value > maximum - visible) {
0897 value = maximum - visible;
0898 }
0899
0900 oldValue = this .value;
0901 this .value = value;
0902 this .visibleAmount = visible;
0903 this .minimum = minimum;
0904 this .maximum = maximum;
0905 ScrollbarPeer peer = (ScrollbarPeer) this .peer;
0906 if (peer != null) {
0907 peer.setValues(value, visibleAmount, minimum, maximum);
0908 }
0909 }
0910
0911 if ((oldValue != value) && (accessibleContext != null)) {
0912 accessibleContext.firePropertyChange(
0913 AccessibleContext.ACCESSIBLE_VALUE_PROPERTY,
0914 Integer.valueOf(oldValue), Integer.valueOf(value));
0915 }
0916 }
0917
0918 /**
0919 * Returns true if the value is in the process of changing as a
0920 * result of actions being taken by the user.
0921 *
0922 * @return the value of the <code>valueIsAdjusting</code> property
0923 * @see #setValueIsAdjusting
0924 * @since 1.4
0925 */
0926 public boolean getValueIsAdjusting() {
0927 return isAdjusting;
0928 }
0929
0930 /**
0931 * Sets the <code>valueIsAdjusting</code> property.
0932 *
0933 * @param b new adjustment-in-progress status
0934 * @see #getValueIsAdjusting
0935 * @since 1.4
0936 */
0937 public void setValueIsAdjusting(boolean b) {
0938 boolean oldValue;
0939
0940 synchronized (this ) {
0941 oldValue = isAdjusting;
0942 isAdjusting = b;
0943 }
0944
0945 if ((oldValue != b) && (accessibleContext != null)) {
0946 accessibleContext.firePropertyChange(
0947 AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
0948 ((oldValue) ? AccessibleState.BUSY : null),
0949 ((b) ? AccessibleState.BUSY : null));
0950 }
0951 }
0952
0953 /**
0954 * Adds the specified adjustment listener to receive instances of
0955 * <code>AdjustmentEvent</code> from this scroll bar.
0956 * If l is <code>null</code>, no exception is thrown and no
0957 * action is performed.
0958 * <p>Refer to <a href="doc-files/AWTThreadIssues.html#ListenersThreads"
0959 * >AWT Threading Issues</a> for details on AWT's threading model.
0960 *
0961 * @param l the adjustment listener
0962 * @see #removeAdjustmentListener
0963 * @see #getAdjustmentListeners
0964 * @see java.awt.event.AdjustmentEvent
0965 * @see java.awt.event.AdjustmentListener
0966 * @since JDK1.1
0967 */
0968 public synchronized void addAdjustmentListener(AdjustmentListener l) {
0969 if (l == null) {
0970 return;
0971 }
0972 adjustmentListener = AWTEventMulticaster.add(
0973 adjustmentListener, l);
0974 newEventsOnly = true;
0975 }
0976
0977 /**
0978 * Removes the specified adjustment listener so that it no longer
0979 * receives instances of <code>AdjustmentEvent</code> from this scroll bar.
0980 * If l is <code>null</code>, no exception is thrown and no action
0981 * is performed.
0982 * <p>Refer to <a href="doc-files/AWTThreadIssues.html#ListenersThreads"
0983 * >AWT Threading Issues</a> for details on AWT's threading model.
0984 *
0985 * @param l the adjustment listener
0986 * @see #addAdjustmentListener
0987 * @see #getAdjustmentListeners
0988 * @see java.awt.event.AdjustmentEvent
0989 * @see java.awt.event.AdjustmentListener
0990 * @since JDK1.1
0991 */
0992 public synchronized void removeAdjustmentListener(
0993 AdjustmentListener l) {
0994 if (l == null) {
0995 return;
0996 }
0997 adjustmentListener = AWTEventMulticaster.remove(
0998 adjustmentListener, l);
0999 }
1000
1001 /**
1002 * Returns an array of all the adjustment listeners
1003 * registered on this scrollbar.
1004 *
1005 * @return all of this scrollbar's <code>AdjustmentListener</code>s
1006 * or an empty array if no adjustment
1007 * listeners are currently registered
1008 * @see #addAdjustmentListener
1009 * @see #removeAdjustmentListener
1010 * @see java.awt.event.AdjustmentEvent
1011 * @see java.awt.event.AdjustmentListener
1012 * @since 1.4
1013 */
1014 public synchronized AdjustmentListener[] getAdjustmentListeners() {
1015 return (AdjustmentListener[]) (getListeners(AdjustmentListener.class));
1016 }
1017
1018 /**
1019 * Returns an array of all the objects currently registered
1020 * as <code><em>Foo</em>Listener</code>s
1021 * upon this <code>Scrollbar</code>.
1022 * <code><em>Foo</em>Listener</code>s are registered using the
1023 * <code>add<em>Foo</em>Listener</code> method.
1024 * <p>
1025 * You can specify the <code>listenerType</code> argument
1026 * with a class literal, such as
1027 * <code><em>Foo</em>Listener.class</code>.
1028 * For example, you can query a
1029 * <code>Scrollbar</code> <code>c</code>
1030 * for its mouse listeners with the following code:
1031 *
1032 * <pre>MouseListener[] mls = (MouseListener[])(c.getListeners(MouseListener.class));</pre>
1033 *
1034 * If no such listeners exist, this method returns an empty array.
1035 *
1036 * @param listenerType the type of listeners requested; this parameter
1037 * should specify an interface that descends from
1038 * <code>java.util.EventListener</code>
1039 * @return an array of all objects registered as
1040 * <code><em>Foo</em>Listener</code>s on this component,
1041 * or an empty array if no such listeners have been added
1042 * @exception ClassCastException if <code>listenerType</code>
1043 * doesn't specify a class or interface that implements
1044 * <code>java.util.EventListener</code>
1045 *
1046 * @since 1.3
1047 */
1048 public <T extends EventListener> T[] getListeners(
1049 Class<T> listenerType) {
1050 EventListener l = null;
1051 if (listenerType == AdjustmentListener.class) {
1052 l = adjustmentListener;
1053 } else {
1054 return super .getListeners(listenerType);
1055 }
1056 return AWTEventMulticaster.getListeners(l, listenerType);
1057 }
1058
1059 // REMIND: remove when filtering is done at lower level
1060 boolean eventEnabled(AWTEvent e) {
1061 if (e.id == AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED) {
1062 if ((eventMask & AWTEvent.ADJUSTMENT_EVENT_MASK) != 0
1063 || adjustmentListener != null) {
1064 return true;
1065 }
1066 return false;
1067 }
1068 return super .eventEnabled(e);
1069 }
1070
1071 /**
1072 * Processes events on this scroll bar. If the event is an
1073 * instance of <code>AdjustmentEvent</code>, it invokes the
1074 * <code>processAdjustmentEvent</code> method.
1075 * Otherwise, it invokes its superclass's
1076 * <code>processEvent</code> method.
1077 * <p>Note that if the event parameter is <code>null</code>
1078 * the behavior is unspecified and may result in an
1079 * exception.
1080 *
1081 * @param e the event
1082 * @see java.awt.event.AdjustmentEvent
1083 * @see java.awt.Scrollbar#processAdjustmentEvent
1084 * @since JDK1.1
1085 */
1086 protected void processEvent(AWTEvent e) {
1087 if (e instanceof AdjustmentEvent) {
1088 processAdjustmentEvent((AdjustmentEvent) e);
1089 return;
1090 }
1091 super .processEvent(e);
1092 }
1093
1094 /**
1095 * Processes adjustment events occurring on this
1096 * scrollbar by dispatching them to any registered
1097 * <code>AdjustmentListener</code> objects.
1098 * <p>
1099 * This method is not called unless adjustment events are
1100 * enabled for this component. Adjustment events are enabled
1101 * when one of the following occurs:
1102 * <p><ul>
1103 * <li>An <code>AdjustmentListener</code> object is registered
1104 * via <code>addAdjustmentListener</code>.
1105 * <li>Adjustment events are enabled via <code>enableEvents</code>.
1106 * </ul><p>
1107 * <p>Note that if the event parameter is <code>null</code>
1108 * the behavior is unspecified and may result in an
1109 * exception.
1110 *
1111 * @param e the adjustment event
1112 * @see java.awt.event.AdjustmentEvent
1113 * @see java.awt.event.AdjustmentListener
1114 * @see java.awt.Scrollbar#addAdjustmentListener
1115 * @see java.awt.Component#enableEvents
1116 * @since JDK1.1
1117 */
1118 protected void processAdjustmentEvent(AdjustmentEvent e) {
1119 AdjustmentListener listener = adjustmentListener;
1120 if (listener != null) {
1121 listener.adjustmentValueChanged(e);
1122 }
1123 }
1124
1125 /**
1126 * Returns a string representing the state of this <code>Scrollbar</code>.
1127 * This method is intended to be used only for debugging purposes, and the
1128 * content and format of the returned string may vary between
1129 * implementations. The returned string may be empty but may not be
1130 * <code>null</code>.
1131 *
1132 * @return the parameter string of this scroll bar
1133 */
1134 protected String paramString() {
1135 return super .paramString() + ",val=" + value + ",vis="
1136 + visibleAmount + ",min=" + minimum + ",max=" + maximum
1137 + ((orientation == VERTICAL) ? ",vert" : ",horz")
1138 + ",isAdjusting=" + isAdjusting;
1139 }
1140
1141 /* Serialization support.
1142 */
1143
1144 /**
1145 * The scroll bar's serialized Data Version.
1146 *
1147 * @serial
1148 */
1149 private int scrollbarSerializedDataVersion = 1;
1150
1151 /**
1152 * Writes default serializable fields to stream. Writes
1153 * a list of serializable <code>AdjustmentListeners</code>
1154 * as optional data. The non-serializable listeners are
1155 * detected and no attempt is made to serialize them.
1156 *
1157 * @param s the <code>ObjectOutputStream</code> to write
1158 * @serialData <code>null</code> terminated sequence of 0
1159 * or more pairs; the pair consists of a <code>String</code>
1160 * and an <code>Object</code>; the <code>String</code> indicates
1161 * the type of object and is one of the following:
1162 * <code>adjustmentListenerK</code> indicating an
1163 * <code>AdjustmentListener</code> object
1164 *
1165 * @see AWTEventMulticaster#save(ObjectOutputStream, String, EventListener)
1166 * @see java.awt.Component#adjustmentListenerK
1167 * @see #readObject(ObjectInputStream)
1168 */
1169 private void writeObject(ObjectOutputStream s) throws IOException {
1170 s.defaultWriteObject();
1171
1172 AWTEventMulticaster.save(s, adjustmentListenerK,
1173 adjustmentListener);
1174 s.writeObject(null);
1175 }
1176
1177 /**
1178 * Reads the <code>ObjectInputStream</code> and if
1179 * it isn't <code>null</code> adds a listener to
1180 * receive adjustment events fired by the
1181 * <code>Scrollbar</code>.
1182 * Unrecognized keys or values will be ignored.
1183 *
1184 * @param s the <code>ObjectInputStream</code> to read
1185 * @exception HeadlessException if
1186 * <code>GraphicsEnvironment.isHeadless</code> returns
1187 * <code>true</code>
1188 * @see java.awt.GraphicsEnvironment#isHeadless
1189 * @see #writeObject(ObjectOutputStream)
1190 */
1191 private void readObject(ObjectInputStream s)
1192 throws ClassNotFoundException, IOException,
1193 HeadlessException {
1194 GraphicsEnvironment.checkHeadless();
1195 s.defaultReadObject();
1196
1197 Object keyOrNull;
1198 while (null != (keyOrNull = s.readObject())) {
1199 String key = ((String) keyOrNull).intern();
1200
1201 if (adjustmentListenerK == key)
1202 addAdjustmentListener((AdjustmentListener) (s
1203 .readObject()));
1204
1205 else
1206 // skip value for unrecognized key
1207 s.readObject();
1208 }
1209 }
1210
1211 /////////////////
1212 // Accessibility support
1213 ////////////////
1214
1215 /**
1216 * Gets the <code>AccessibleContext</code> associated with this
1217 * <code>Scrollbar</code>. For scrollbars, the
1218 * <code>AccessibleContext</code> takes the form of an
1219 * <code>AccessibleAWTScrollBar</code>. A new
1220 * <code>AccessibleAWTScrollBar</code> instance is created if necessary.
1221 *
1222 * @return an <code>AccessibleAWTScrollBar</code> that serves as the
1223 * <code>AccessibleContext</code> of this <code>ScrollBar</code>
1224 * @since 1.3
1225 */
1226 public AccessibleContext getAccessibleContext() {
1227 if (accessibleContext == null) {
1228 accessibleContext = new AccessibleAWTScrollBar();
1229 }
1230 return accessibleContext;
1231 }
1232
1233 /**
1234 * This class implements accessibility support for the
1235 * <code>Scrollbar</code> class. It provides an implementation of
1236 * the Java Accessibility API appropriate to scrollbar
1237 * user-interface elements.
1238 * @since 1.3
1239 */
1240 protected class AccessibleAWTScrollBar extends
1241 AccessibleAWTComponent implements AccessibleValue {
1242 /*
1243 * JDK 1.3 serialVersionUID
1244 */
1245 private static final long serialVersionUID = -344337268523697807L;
1246
1247 /**
1248 * Get the state set of this object.
1249 *
1250 * @return an instance of <code>AccessibleState</code>
1251 * containing the current state of the object
1252 * @see AccessibleState
1253 */
1254 public AccessibleStateSet getAccessibleStateSet() {
1255 AccessibleStateSet states = super .getAccessibleStateSet();
1256 if (getValueIsAdjusting()) {
1257 states.add(AccessibleState.BUSY);
1258 }
1259 if (getOrientation() == VERTICAL) {
1260 states.add(AccessibleState.VERTICAL);
1261 } else {
1262 states.add(AccessibleState.HORIZONTAL);
1263 }
1264 return states;
1265 }
1266
1267 /**
1268 * Get the role of this object.
1269 *
1270 * @return an instance of <code>AccessibleRole</code>
1271 * describing the role of the object
1272 */
1273 public AccessibleRole getAccessibleRole() {
1274 return AccessibleRole.SCROLL_BAR;
1275 }
1276
1277 /**
1278 * Get the <code>AccessibleValue</code> associated with this
1279 * object. In the implementation of the Java Accessibility
1280 * API for this class, return this object, which is
1281 * responsible for implementing the
1282 * <code>AccessibleValue</code> interface on behalf of itself.
1283 *
1284 * @return this object
1285 */
1286 public AccessibleValue getAccessibleValue() {
1287 return this ;
1288 }
1289
1290 /**
1291 * Get the accessible value of this object.
1292 *
1293 * @return The current value of this object.
1294 */
1295 public Number getCurrentAccessibleValue() {
1296 return Integer.valueOf(getValue());
1297 }
1298
1299 /**
1300 * Set the value of this object as a Number.
1301 *
1302 * @return True if the value was set.
1303 */
1304 public boolean setCurrentAccessibleValue(Number n) {
1305 if (n instanceof Integer) {
1306 setValue(n.intValue());
1307 return true;
1308 } else {
1309 return false;
1310 }
1311 }
1312
1313 /**
1314 * Get the minimum accessible value of this object.
1315 *
1316 * @return The minimum value of this object.
1317 */
1318 public Number getMinimumAccessibleValue() {
1319 return Integer.valueOf(getMinimum());
1320 }
1321
1322 /**
1323 * Get the maximum accessible value of this object.
1324 *
1325 * @return The maximum value of this object.
1326 */
1327 public Number getMaximumAccessibleValue() {
1328 return Integer.valueOf(getMaximum());
1329 }
1330
1331 } // AccessibleAWTScrollBar
1332
1333 }
|