History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/java/awt/Scrollbar.java (1 of 18352 files). Show all

Unified · Split

java/pkg/java/awt/Scrollbar.java+1337−0
@@ -0,0 +1,1337 @@
1+/*
2+ * Copyright (c) 1995, 2010, Oracle and/or its affiliates. All rights reserved.
3+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+ *
5+ * This code is free software; you can redistribute it and/or modify it
6+ * under the terms of the GNU General Public License version 2 only, as
7+ * published by the Free Software Foundation. Oracle designates this
8+ * particular file as subject to the "Classpath" exception as provided
9+ * by Oracle in the LICENSE file that accompanied this code.
10+ *
11+ * This code is distributed in the hope that it will be useful, but WITHOUT
12+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14+ * version 2 for more details (a copy is included in the LICENSE file that
15+ * accompanied this code).
16+ *
17+ * You should have received a copy of the GNU General Public License version
18+ * 2 along with this work; if not, write to the Free Software Foundation,
19+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20+ *
21+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22+ * or visit www.oracle.com if you need additional information or have any
23+ * questions.
24+ */
25+package java.awt;
26+
27+import java.awt.peer.ScrollbarPeer;
28+import java.awt.event.*;
29+import java.util.EventListener;
30+import java.io.ObjectOutputStream;
31+import java.io.ObjectInputStream;
32+import java.io.IOException;
33+import javax.accessibility.*;
34+
35+
36+/**
37+ * The <code>Scrollbar</code> class embodies a scroll bar, a
38+ * familiar user-interface object. A scroll bar provides a
39+ * convenient means for allowing a user to select from a
40+ * range of values. The following three vertical
41+ * scroll bars could be used as slider controls to pick
42+ * the red, green, and blue components of a color:
43+ * <p>
44+ * <img src="doc-files/Scrollbar-1.gif" alt="Image shows 3 vertical sliders, side-by-side."
45+ * ALIGN=center HSPACE=10 VSPACE=7>
46+ * <p>
47+ * Each scroll bar in this example could be created with
48+ * code similar to the following:
49+ * <p>
50+ * <hr><blockquote><pre>
51+ * redSlider=new Scrollbar(Scrollbar.VERTICAL, 0, 1, 0, 255);
52+ * add(redSlider);
53+ * </pre></blockquote><hr>
54+ * <p>
55+ * Alternatively, a scroll bar can represent a range of values. For
56+ * example, if a scroll bar is used for scrolling through text, the
57+ * width of the "bubble" (also called the "thumb" or "scroll box")
58+ * can be used to represent the amount of text that is visible.
59+ * Here is an example of a scroll bar that represents a range:
60+ * <p>
61+ * <img src="doc-files/Scrollbar-2.gif"
62+ * alt="Image shows horizontal slider with starting range of 0 and ending range of 300. The slider thumb is labeled 60."
63+ * ALIGN=center HSPACE=10 VSPACE=7>
64+ * <p>
65+ * The value range represented by the bubble in this example
66+ * is the <em>visible amount</em>. The horizontal scroll bar
67+ * in this example could be created with code like the following:
68+ * <p>
69+ * <hr><blockquote><pre>
70+ * ranger = new Scrollbar(Scrollbar.HORIZONTAL, 0, 60, 0, 300);
71+ * add(ranger);
72+ * </pre></blockquote><hr>
73+ * <p>
74+ * Note that the actual maximum value of the scroll bar is the
75+ * <code>maximum</code> minus the <code>visible amount</code>.
76+ * In the previous example, because the <code>maximum</code> is
77+ * 300 and the <code>visible amount</code> is 60, the actual maximum
78+ * value is 240. The range of the scrollbar track is 0 - 300.
79+ * The left side of the bubble indicates the value of the
80+ * scroll bar.
81+ * <p>
82+ * Normally, the user changes the value of the scroll bar by
83+ * making a gesture with the mouse. For example, the user can
84+ * drag the scroll bar's bubble up and down, or click in the
85+ * scroll bar's unit increment or block increment areas. Keyboard
86+ * gestures can also be mapped to the scroll bar. By convention,
87+ * the <b>Page&nbsp;Up</b> and <b>Page&nbsp;Down</b>
88+ * keys are equivalent to clicking in the scroll bar's block
89+ * increment and block decrement areas.
90+ * <p>
91+ * When the user changes the value of the scroll bar, the scroll bar
92+ * receives an instance of <code>AdjustmentEvent</code>.
93+ * The scroll bar processes this event, passing it along to
94+ * any registered listeners.
95+ * <p>
96+ * Any object that wishes to be notified of changes to the
97+ * scroll bar's value should implement
98+ * <code>AdjustmentListener</code>, an interface defined in
99+ * the package <code>java.awt.event</code>.
100+ * Listeners can be added and removed dynamically by calling
101+ * the methods <code>addAdjustmentListener</code> and
102+ * <code>removeAdjustmentListener</code>.
103+ * <p>
104+ * The <code>AdjustmentEvent</code> class defines five types
105+ * of adjustment event, listed here:
106+ * <p>
107+ * <ul>
108+ * <li><code>AdjustmentEvent.TRACK</code> is sent out when the
109+ * user drags the scroll bar's bubble.
110+ * <li><code>AdjustmentEvent.UNIT_INCREMENT</code> is sent out
111+ * when the user clicks in the left arrow of a horizontal scroll
112+ * bar, or the top arrow of a vertical scroll bar, or makes the
113+ * equivalent gesture from the keyboard.
114+ * <li><code>AdjustmentEvent.UNIT_DECREMENT</code> is sent out
115+ * when the user clicks in the right arrow of a horizontal scroll
116+ * bar, or the bottom arrow of a vertical scroll bar, or makes the
117+ * equivalent gesture from the keyboard.
118+ * <li><code>AdjustmentEvent.BLOCK_INCREMENT</code> is sent out
119+ * when the user clicks in the track, to the left of the bubble
120+ * on a horizontal scroll bar, or above the bubble on a vertical
121+ * scroll bar. By convention, the <b>Page&nbsp;Up</b>
122+ * key is equivalent, if the user is using a keyboard that
123+ * defines a <b>Page&nbsp;Up</b> key.
124+ * <li><code>AdjustmentEvent.BLOCK_DECREMENT</code> is sent out
125+ * when the user clicks in the track, to the right of the bubble
126+ * on a horizontal scroll bar, or below the bubble on a vertical
127+ * scroll bar. By convention, the <b>Page&nbsp;Down</b>
128+ * key is equivalent, if the user is using a keyboard that
129+ * defines a <b>Page&nbsp;Down</b> key.
130+ * </ul>
131+ * <p>
132+ * The JDK&nbsp;1.0 event system is supported for backwards
133+ * compatibility, but its use with newer versions of the platform is
134+ * discouraged. The five types of adjustment events introduced
135+ * with JDK&nbsp;1.1 correspond to the five event types
136+ * that are associated with scroll bars in previous platform versions.
137+ * The following list gives the adjustment event type,
138+ * and the corresponding JDK&nbsp;1.0 event type it replaces.
139+ * <p>
140+ * <ul>
141+ * <li><code>AdjustmentEvent.TRACK</code> replaces
142+ * <code>Event.SCROLL_ABSOLUTE</code>
143+ * <li><code>AdjustmentEvent.UNIT_INCREMENT</code> replaces
144+ * <code>Event.SCROLL_LINE_UP</code>
145+ * <li><code>AdjustmentEvent.UNIT_DECREMENT</code> replaces
146+ * <code>Event.SCROLL_LINE_DOWN</code>
147+ * <li><code>AdjustmentEvent.BLOCK_INCREMENT</code> replaces
148+ * <code>Event.SCROLL_PAGE_UP</code>
149+ * <li><code>AdjustmentEvent.BLOCK_DECREMENT</code> replaces
150+ * <code>Event.SCROLL_PAGE_DOWN</code>
151+ * </ul>
152+ * <p>
153+ * <b>Note</b>: We recommend using a <code>Scrollbar</code>
154+ * for value selection only. If you want to implement
155+ * a scrollable component inside a container, we recommend you use
156+ * a {@link ScrollPane ScrollPane}. If you use a
157+ * <code>Scrollbar</code> for this purpose, you are likely to
158+ * encounter issues with painting, key handling, sizing and
159+ * positioning.
160+ *
161+ * @author Sami Shaio
162+ * @see java.awt.event.AdjustmentEvent
163+ * @see java.awt.event.AdjustmentListener
164+ * @since JDK1.0
165+ */
166+public class Scrollbar extends Component implements Adjustable, Accessible {
167+
168+ /**
169+ * A constant that indicates a horizontal scroll bar.
170+ */
171+ public static final int HORIZONTAL = 0;
172+
173+ /**
174+ * A constant that indicates a vertical scroll bar.
175+ */
176+ public static final int VERTICAL = 1;
177+
178+ /**
179+ * The value of the <code>Scrollbar</code>.
180+ * This property must be greater than or equal to <code>minimum</code>
181+ * and less than or equal to
182+ * <code>maximum - visibleAmount</code>
183+ *
184+ * @serial
185+ * @see #getValue
186+ * @see #setValue
187+ */
188+ int value;
189+
190+ /**
191+ * The maximum value of the <code>Scrollbar</code>.
192+ * This value must be greater than the <code>minimum</code>
193+ * value.<br>
194+ *
195+ * @serial
196+ * @see #getMaximum
197+ * @see #setMaximum
198+ */
199+ int maximum;
200+
201+ /**
202+ * The minimum value of the <code>Scrollbar</code>.
203+ * This value must be less than the <code>maximum</code>
204+ * value.<br>
205+ *
206+ * @serial
207+ * @see #getMinimum
208+ * @see #setMinimum
209+ */
210+ int minimum;
211+
212+ /**
213+ * The size of the <code>Scrollbar</code>'s bubble.
214+ * When a scroll bar is used to select a range of values,
215+ * the visibleAmount represents the size of this range.
216+ * Depending on platform, this may be visually indicated
217+ * by the size of the bubble.
218+ *
219+ * @serial
220+ * @see #getVisibleAmount
221+ * @see #setVisibleAmount
222+ */
223+ int visibleAmount;
224+
225+ /**
226+ * The <code>Scrollbar</code>'s orientation--being either horizontal
227+ * or vertical.
228+ * This value should be specified when the scrollbar is created.<BR>
229+ * orientation can be either : <code>VERTICAL</code> or
230+ * <code>HORIZONTAL</code> only.
231+ *
232+ * @serial
233+ * @see #getOrientation
234+ * @see #setOrientation
235+ */
236+ int orientation;
237+
238+ /**
239+ * The amount by which the scrollbar value will change when going
240+ * up or down by a line.
241+ * This value must be greater than zero.
242+ *
243+ * @serial
244+ * @see #getLineIncrement
245+ * @see #setLineIncrement
246+ */
247+ int lineIncrement = 1;
248+
249+ /**
250+ * The amount by which the scrollbar value will change when going
251+ * up or down by a page.
252+ * This value must be greater than zero.
253+ *
254+ * @serial
255+ * @see #getPageIncrement
256+ * @see #setPageIncrement
257+ */
258+ int pageIncrement = 10;
259+
260+ /**
261+ * The adjusting status of the <code>Scrollbar</code>.
262+ * True if the value is in the process of changing as a result of
263+ * actions being taken by the user.
264+ *
265+ * @see #getValueIsAdjusting
266+ * @see #setValueIsAdjusting
267+ * @since 1.4
268+ */
269+ transient boolean isAdjusting;
270+
271+ transient AdjustmentListener adjustmentListener;
272+
273+ private static final String base = "scrollbar";
274+ private static int nameCounter = 0;
275+
276+ /*
277+ * JDK 1.1 serialVersionUID
278+ */
279+ private static final long serialVersionUID = 8451667562882310543L;
280+
281+ /**
282+ * Initialize JNI field and method IDs.
283+ */
284+ private static native void initIDs();
285+
286+ static {
287+ /* ensure that the necessary native libraries are loaded */
288+ Toolkit.loadLibraries();
289+ if (!GraphicsEnvironment.isHeadless()) {
290+ initIDs();
291+ }
292+ }
293+
294+ /**
295+ * Constructs a new vertical scroll bar.
296+ * The default properties of the scroll bar are listed in
297+ * the following table:
298+ * <p> </p>
299+ * <table border=1 summary="Scrollbar default properties">
300+ * <tr>
301+ * <th>Property</th>
302+ * <th>Description</th>
303+ * <th>Default Value</th>
304+ * </tr>
305+ * <tr>
306+ * <td>orientation</td>
307+ * <td>indicates whether the scroll bar is vertical
308+ * <br>or horizontal</td>
309+ * <td><code>Scrollbar.VERTICAL</code></td>
310+ * </tr>
311+ * <tr>
312+ * <td>value</td>
313+ * <td>value which controls the location
314+ * <br>of the scroll bar's bubble</td>
315+ * <td>0</td>
316+ * </tr>
317+ * <tr>
318+ * <td>visible amount</td>
319+ * <td>visible amount of the scroll bar's range,
320+ * <br>typically represented by the size of the
321+ * <br>scroll bar's bubble</td>
322+ * <td>10</td>
323+ * </tr>
324+ * <tr>
325+ * <td>minimum</td>
326+ * <td>minimum value of the scroll bar</td>
327+ * <td>0</td>
328+ * </tr>
329+ * <tr>
330+ * <td>maximum</td>
331+ * <td>maximum value of the scroll bar</td>
332+ * <td>100</td>
333+ * </tr>
334+ * <tr>
335+ * <td>unit increment</td>
336+ * <td>amount the value changes when the
337+ * <br>Line Up or Line Down key is pressed,
338+ * <br>or when the end arrows of the scrollbar
339+ * <br>are clicked </td>
340+ * <td>1</td>
341+ * </tr>
342+ * <tr>
343+ * <td>block increment</td>
344+ * <td>amount the value changes when the
345+ * <br>Page Up or Page Down key is pressed,
346+ * <br>or when the scrollbar track is clicked
347+ * <br>on either side of the bubble </td>
348+ * <td>10</td>
349+ * </tr>
350+ * </table>
351+ *
352+ * @exception HeadlessException if GraphicsEnvironment.isHeadless()
353+ * returns true.
354+ * @see java.awt.GraphicsEnvironment#isHeadless
355+ */
356+ public Scrollbar() throws HeadlessException {
357+ this(VERTICAL, 0, 10, 0, 100);
358+ }
359+
360+ /**
361+ * Constructs a new scroll bar with the specified orientation.
362+ * <p>
363+ * The <code>orientation</code> argument must take one of the two
364+ * values <code>Scrollbar.HORIZONTAL</code>,
365+ * or <code>Scrollbar.VERTICAL</code>,
366+ * indicating a horizontal or vertical scroll bar, respectively.
367+ *
368+ * @param orientation indicates the orientation of the scroll bar
369+ * @exception IllegalArgumentException when an illegal value for
370+ * the <code>orientation</code> argument is supplied
371+ * @exception HeadlessException if GraphicsEnvironment.isHeadless()
372+ * returns true.
373+ * @see java.awt.GraphicsEnvironment#isHeadless
374+ */
375+ public Scrollbar(int orientation) throws HeadlessException {
376+ this(orientation, 0, 10, 0, 100);
377+ }
378+
379+ /**
380+ * Constructs a new scroll bar with the specified orientation,
381+ * initial value, visible amount, and minimum and maximum values.
382+ * <p>
383+ * The <code>orientation</code> argument must take one of the two
384+ * values <code>Scrollbar.HORIZONTAL</code>,
385+ * or <code>Scrollbar.VERTICAL</code>,
386+ * indicating a horizontal or vertical scroll bar, respectively.
387+ * <p>
388+ * The parameters supplied to this constructor are subject to the
389+ * constraints described in {@link #setValues(int, int, int, int)}.
390+ *
391+ * @param orientation indicates the orientation of the scroll bar.
392+ * @param value the initial value of the scroll bar
393+ * @param visible the visible amount of the scroll bar, typically
394+ * represented by the size of the bubble
395+ * @param minimum the minimum value of the scroll bar
396+ * @param maximum the maximum value of the scroll bar
397+ * @exception IllegalArgumentException when an illegal value for
398+ * the <code>orientation</code> argument is supplied
399+ * @exception HeadlessException if GraphicsEnvironment.isHeadless()
400+ * returns true.
401+ * @see #setValues
402+ * @see java.awt.GraphicsEnvironment#isHeadless
403+ */
404+ public Scrollbar(int orientation, int value, int visible, int minimum,
405+ int maximum) throws HeadlessException {
406+ GraphicsEnvironment.checkHeadless();
407+ switch (orientation) {
408+ case HORIZONTAL:
409+ case VERTICAL:
410+ this.orientation = orientation;
411+ break;
412+ default:
413+ throw new IllegalArgumentException("illegal scrollbar orientation");
414+ }
415+ setValues(value, visible, minimum, maximum);
416+ }
417+
418+ /**
419+ * Constructs a name for this component. Called by <code>getName</code>
420+ * when the name is <code>null</code>.
421+ */
422+ String constructComponentName() {
423+ synchronized (Scrollbar.class) {
424+ return base + nameCounter++;
425+ }
426+ }
427+
428+ /**
429+ * Creates the <code>Scrollbar</code>'s peer. The peer allows you to modify
430+ * the appearance of the <code>Scrollbar</code> without changing any of its
431+ * functionality.
432+ */
433+ public void addNotify() {
434+ synchronized (getTreeLock()) {
435+ if (peer == null)
436+ peer = getToolkit().createScrollbar(this);
437+ super.addNotify();
438+ }
439+ }
440+
441+ /**
442+ * Returns the orientation of this scroll bar.
443+ *
444+ * @return the orientation of this scroll bar, either
445+ * <code>Scrollbar.HORIZONTAL</code> or
446+ * <code>Scrollbar.VERTICAL</code>
447+ * @see java.awt.Scrollbar#setOrientation
448+ */
449+ public int getOrientation() {
450+ return orientation;
451+ }
452+
453+ /**
454+ * Sets the orientation for this scroll bar.
455+ *
456+ * @param orientation the orientation of this scroll bar, either
457+ * <code>Scrollbar.HORIZONTAL</code> or
458+ * <code>Scrollbar.VERTICAL</code>
459+ * @see java.awt.Scrollbar#getOrientation
460+ * @exception IllegalArgumentException if the value supplied
461+ * for <code>orientation</code> is not a
462+ * legal value
463+ * @since JDK1.1
464+ */
465+ public void setOrientation(int orientation) {
466+ synchronized (getTreeLock()) {
467+ if (orientation == this.orientation) {
468+ return;
469+ }
470+ switch (orientation) {
471+ case HORIZONTAL:
472+ case VERTICAL:
473+ this.orientation = orientation;
474+ break;
475+ default:
476+ throw new IllegalArgumentException("illegal scrollbar orientation");
477+ }
478+ /* Create a new peer with the specified orientation. */
479+ if (peer != null) {
480+ removeNotify();
481+ addNotify();
482+ invalidate();
483+ }
484+ }
485+ if (accessibleContext != null) {
486+ accessibleContext.firePropertyChange(
487+ AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
488+ ((orientation == VERTICAL)
489+ ? AccessibleState.HORIZONTAL : AccessibleState.VERTICAL),
490+ ((orientation == VERTICAL)
491+ ? AccessibleState.VERTICAL : AccessibleState.HORIZONTAL));
492+ }
493+ }
494+
495+ /**
496+ * Gets the current value of this scroll bar.
497+ *
498+ * @return the current value of this scroll bar
499+ * @see java.awt.Scrollbar#getMinimum
500+ * @see java.awt.Scrollbar#getMaximum
501+ */
502+ public int getValue() {
503+ return value;
504+ }
505+
506+ /**
507+ * Sets the value of this scroll bar to the specified value.
508+ * <p>
509+ * If the value supplied is less than the current <code>minimum</code>
510+ * or greater than the current <code>maximum - visibleAmount</code>,
511+ * then either <code>minimum</code> or <code>maximum - visibleAmount</code>
512+ * is substituted, as appropriate.
513+ * <p>
514+ * Normally, a program should change a scroll bar's
515+ * value only by calling <code>setValues</code>.
516+ * The <code>setValues</code> method simultaneously
517+ * and synchronously sets the minimum, maximum, visible amount,
518+ * and value properties of a scroll bar, so that they are
519+ * mutually consistent.
520+ * <p>
521+ * Calling this method does not fire an
522+ * <code>AdjustmentEvent</code>.
523+ *
524+ * @param newValue the new value of the scroll bar
525+ * @see java.awt.Scrollbar#setValues
526+ * @see java.awt.Scrollbar#getValue
527+ * @see java.awt.Scrollbar#getMinimum
528+ * @see java.awt.Scrollbar#getMaximum
529+ */
530+ public void setValue(int newValue) {
531+ // Use setValues so that a consistent policy relating
532+ // minimum, maximum, visible amount, and value is enforced.
533+ setValues(newValue, visibleAmount, minimum, maximum);
534+ }
535+
536+ /**
537+ * Gets the minimum value of this scroll bar.
538+ *
539+ * @return the minimum value of this scroll bar
540+ * @see java.awt.Scrollbar#getValue
541+ * @see java.awt.Scrollbar#getMaximum
542+ */
543+ public int getMinimum() {
544+ return minimum;
545+ }
546+
547+ /**
548+ * Sets the minimum value of this scroll bar.
549+ * <p>
550+ * When <code>setMinimum</code> is called, the minimum value
551+ * is changed, and other values (including the maximum, the
552+ * visible amount, and the current scroll bar value)
553+ * are changed to be consistent with the new minimum.
554+ * <p>
555+ * Normally, a program should change a scroll bar's minimum
556+ * value only by calling <code>setValues</code>.
557+ * The <code>setValues</code> method simultaneously
558+ * and synchronously sets the minimum, maximum, visible amount,
559+ * and value properties of a scroll bar, so that they are
560+ * mutually consistent.
561+ * <p>
562+ * Note that setting the minimum value to <code>Integer.MAX_VALUE</code>
563+ * will result in the new minimum value being set to
564+ * <code>Integer.MAX_VALUE - 1</code>.
565+ *
566+ * @param newMinimum the new minimum value for this scroll bar
567+ * @see java.awt.Scrollbar#setValues
568+ * @see java.awt.Scrollbar#setMaximum
569+ * @since JDK1.1
570+ */
571+ public void setMinimum(int newMinimum) {
572+ // No checks are necessary in this method since minimum is
573+ // the first variable checked in the setValues function.
574+
575+ // Use setValues so that a consistent policy relating
576+ // minimum, maximum, visible amount, and value is enforced.
577+ setValues(value, visibleAmount, newMinimum, maximum);
578+ }
579+
580+ /**
581+ * Gets the maximum value of this scroll bar.
582+ *
583+ * @return the maximum value of this scroll bar
584+ * @see java.awt.Scrollbar#getValue
585+ * @see java.awt.Scrollbar#getMinimum
586+ */
587+ public int getMaximum() {
588+ return maximum;
589+ }
590+
591+ /**
592+ * Sets the maximum value of this scroll bar.
593+ * <p>
594+ * When <code>setMaximum</code> is called, the maximum value
595+ * is changed, and other values (including the minimum, the
596+ * visible amount, and the current scroll bar value)
597+ * are changed to be consistent with the new maximum.
598+ * <p>
599+ * Normally, a program should change a scroll bar's maximum
600+ * value only by calling <code>setValues</code>.
601+ * The <code>setValues</code> method simultaneously
602+ * and synchronously sets the minimum, maximum, visible amount,
603+ * and value properties of a scroll bar, so that they are
604+ * mutually consistent.
605+ * <p>
606+ * Note that setting the maximum value to <code>Integer.MIN_VALUE</code>
607+ * will result in the new maximum value being set to
608+ * <code>Integer.MIN_VALUE + 1</code>.
609+ *
610+ * @param newMaximum the new maximum value
611+ * for this scroll bar
612+ * @see java.awt.Scrollbar#setValues
613+ * @see java.awt.Scrollbar#setMinimum
614+ * @since JDK1.1
615+ */
616+ public void setMaximum(int newMaximum) {
617+ // minimum is checked first in setValues, so we need to
618+ // enforce minimum and maximum checks here.
619+ if (newMaximum == Integer.MIN_VALUE) {
620+ newMaximum = Integer.MIN_VALUE + 1;
621+ }
622+
623+ if (minimum >= newMaximum) {
624+ minimum = newMaximum - 1;
625+ }
626+
627+ // Use setValues so that a consistent policy relating
628+ // minimum, maximum, visible amount, and value is enforced.
629+ setValues(value, visibleAmount, minimum, newMaximum);
630+ }
631+
632+ /**
633+ * Gets the visible amount of this scroll bar.
634+ * <p>
635+ * When a scroll bar is used to select a range of values,
636+ * the visible amount is used to represent the range of values
637+ * that are currently visible. The size of the scroll bar's
638+ * bubble (also called a thumb or scroll box), usually gives a
639+ * visual representation of the relationship of the visible
640+ * amount to the range of the scroll bar.
641+ * Note that depending on platform, the value of the visible amount property
642+ * may not be visually indicated by the size of the bubble.
643+ * <p>
644+ * The scroll bar's bubble may not be displayed when it is not
645+ * moveable (e.g. when it takes up the entire length of the
646+ * scroll bar's track, or when the scroll bar is disabled).
647+ * Whether the bubble is displayed or not will not affect
648+ * the value returned by <code>getVisibleAmount</code>.
649+ *
650+ * @return the visible amount of this scroll bar
651+ * @see java.awt.Scrollbar#setVisibleAmount
652+ * @since JDK1.1
653+ */
654+ public int getVisibleAmount() {
655+ return getVisible();
656+ }
657+
658+ /**
659+ * @deprecated As of JDK version 1.1,
660+ * replaced by <code>getVisibleAmount()</code>.
661+ */
662+ @Deprecated
663+ public int getVisible() {
664+ return visibleAmount;
665+ }
666+
667+ /**
668+ * Sets the visible amount of this scroll bar.
669+ * <p>
670+ * When a scroll bar is used to select a range of values,
671+ * the visible amount is used to represent the range of values
672+ * that are currently visible. The size of the scroll bar's
673+ * bubble (also called a thumb or scroll box), usually gives a
674+ * visual representation of the relationship of the visible
675+ * amount to the range of the scroll bar.
676+ * Note that depending on platform, the value of the visible amount property
677+ * may not be visually indicated by the size of the bubble.
678+ * <p>
679+ * The scroll bar's bubble may not be displayed when it is not
680+ * moveable (e.g. when it takes up the entire length of the
681+ * scroll bar's track, or when the scroll bar is disabled).
682+ * Whether the bubble is displayed or not will not affect
683+ * the value returned by <code>getVisibleAmount</code>.
684+ * <p>
685+ * If the visible amount supplied is less than <code>one</code>
686+ * or greater than the current <code>maximum - minimum</code>,
687+ * then either <code>one</code> or <code>maximum - minimum</code>
688+ * is substituted, as appropriate.
689+ * <p>
690+ * Normally, a program should change a scroll bar's
691+ * value only by calling <code>setValues</code>.
692+ * The <code>setValues</code> method simultaneously
693+ * and synchronously sets the minimum, maximum, visible amount,
694+ * and value properties of a scroll bar, so that they are
695+ * mutually consistent.
696+ *
697+ * @param newAmount the new visible amount
698+ * @see java.awt.Scrollbar#getVisibleAmount
699+ * @see java.awt.Scrollbar#setValues
700+ * @since JDK1.1
701+ */
702+ public void setVisibleAmount(int newAmount) {
703+ // Use setValues so that a consistent policy relating
704+ // minimum, maximum, visible amount, and value is enforced.
705+ setValues(value, newAmount, minimum, maximum);
706+ }
707+
708+ /**
709+ * Sets the unit increment for this scroll bar.
710+ * <p>
711+ * The unit increment is the value that is added or subtracted
712+ * when the user activates the unit increment area of the
713+ * scroll bar, generally through a mouse or keyboard gesture
714+ * that the scroll bar receives as an adjustment event.
715+ * The unit increment must be greater than zero.
716+ * Attepts to set the unit increment to a value lower than 1
717+ * will result in a value of 1 being set.
718+ *
719+ * @param v the amount by which to increment or decrement
720+ * the scroll bar's value
721+ * @see java.awt.Scrollbar#getUnitIncrement
722+ * @since JDK1.1
723+ */
724+ public void setUnitIncrement(int v) {
725+ setLineIncrement(v);
726+ }
727+
728+ /**
729+ * @deprecated As of JDK version 1.1,
730+ * replaced by <code>setUnitIncrement(int)</code>.
731+ */
732+ @Deprecated
733+ public synchronized void setLineIncrement(int v) {
734+ int tmp = (v < 1) ? 1 : v;
735+
736+ if (lineIncrement == tmp) {
737+ return;
738+ }
739+ lineIncrement = tmp;
740+
741+ ScrollbarPeer peer = (ScrollbarPeer)this.peer;
742+ if (peer != null) {
743+ peer.setLineIncrement(lineIncrement);
744+ }
745+ }
746+
747+ /**
748+ * Gets the unit increment for this scrollbar.
749+ * <p>
750+ * The unit increment is the value that is added or subtracted
751+ * when the user activates the unit increment area of the
752+ * scroll bar, generally through a mouse or keyboard gesture
753+ * that the scroll bar receives as an adjustment event.
754+ * The unit increment must be greater than zero.
755+ *
756+ * @return the unit increment of this scroll bar
757+ * @see java.awt.Scrollbar#setUnitIncrement
758+ * @since JDK1.1
759+ */
760+ public int getUnitIncrement() {
761+ return getLineIncrement();
762+ }
763+
764+ /**
765+ * @deprecated As of JDK version 1.1,
766+ * replaced by <code>getUnitIncrement()</code>.
767+ */
768+ @Deprecated
769+ public int getLineIncrement() {
770+ return lineIncrement;
771+ }
772+
773+ /**
774+ * Sets the block increment for this scroll bar.
775+ * <p>
776+ * The block increment is the value that is added or subtracted
777+ * when the user activates the block increment area of the
778+ * scroll bar, generally through a mouse or keyboard gesture
779+ * that the scroll bar receives as an adjustment event.
780+ * The block increment must be greater than zero.
781+ * Attepts to set the block increment to a value lower than 1
782+ * will result in a value of 1 being set.
783+ *
784+ * @param v the amount by which to increment or decrement
785+ * the scroll bar's value
786+ * @see java.awt.Scrollbar#getBlockIncrement
787+ * @since JDK1.1
788+ */
789+ public void setBlockIncrement(int v) {
790+ setPageIncrement(v);
791+ }
792+
793+ /**
794+ * @deprecated As of JDK version 1.1,
795+ * replaced by <code>setBlockIncrement()</code>.
796+ */
797+ @Deprecated
798+ public synchronized void setPageIncrement(int v) {
799+ int tmp = (v < 1) ? 1 : v;
800+
801+ if (pageIncrement == tmp) {
802+ return;
803+ }
804+ pageIncrement = tmp;
805+
806+ ScrollbarPeer peer = (ScrollbarPeer)this.peer;
807+ if (peer != null) {
808+ peer.setPageIncrement(pageIncrement);
809+ }
810+ }
811+
812+ /**
813+ * Gets the block increment of this scroll bar.
814+ * <p>
815+ * The block increment is the value that is added or subtracted
816+ * when the user activates the block increment area of the
817+ * scroll bar, generally through a mouse or keyboard gesture
818+ * that the scroll bar receives as an adjustment event.
819+ * The block increment must be greater than zero.
820+ *
821+ * @return the block increment of this scroll bar
822+ * @see java.awt.Scrollbar#setBlockIncrement
823+ * @since JDK1.1
824+ */
825+ public int getBlockIncrement() {
826+ return getPageIncrement();
827+ }
828+
829+ /**
830+ * @deprecated As of JDK version 1.1,
831+ * replaced by <code>getBlockIncrement()</code>.
832+ */
833+ @Deprecated
834+ public int getPageIncrement() {
835+ return pageIncrement;
836+ }
837+
838+ /**
839+ * Sets the values of four properties for this scroll bar:
840+ * <code>value</code>, <code>visibleAmount</code>,
841+ * <code>minimum</code>, and <code>maximum</code>.
842+ * If the values supplied for these properties are inconsistent
843+ * or incorrect, they will be changed to ensure consistency.
844+ * <p>
845+ * This method simultaneously and synchronously sets the values
846+ * of four scroll bar properties, assuring that the values of
847+ * these properties are mutually consistent. It enforces the
848+ * following constraints:
849+ * <code>maximum</code> must be greater than <code>minimum</code>,
850+ * <code>maximum - minimum</code> must not be greater
851+ * than <code>Integer.MAX_VALUE</code>,
852+ * <code>visibleAmount</code> must be greater than zero.
853+ * <code>visibleAmount</code> must not be greater than
854+ * <code>maximum - minimum</code>,
855+ * <code>value</code> must not be less than <code>minimum</code>,
856+ * and <code>value</code> must not be greater than
857+ * <code>maximum - visibleAmount</code>
858+ * <p>
859+ * Calling this method does not fire an
860+ * <code>AdjustmentEvent</code>.
861+ *
862+ * @param value is the position in the current window
863+ * @param visible is the visible amount of the scroll bar
864+ * @param minimum is the minimum value of the scroll bar
865+ * @param maximum is the maximum value of the scroll bar
866+ * @see #setMinimum
867+ * @see #setMaximum
868+ * @see #setVisibleAmount
869+ * @see #setValue
870+ */
871+ public void setValues(int value, int visible, int minimum, int maximum) {
872+ int oldValue;
873+ synchronized (this) {
874+ if (minimum == Integer.MAX_VALUE) {
875+ minimum = Integer.MAX_VALUE - 1;
876+ }
877+ if (maximum <= minimum) {
878+ maximum = minimum + 1;
879+ }
880+
881+ long maxMinusMin = (long) maximum - (long) minimum;
882+ if (maxMinusMin > Integer.MAX_VALUE) {
883+ maxMinusMin = Integer.MAX_VALUE;
884+ maximum = minimum + (int) maxMinusMin;
885+ }
886+ if (visible > (int) maxMinusMin) {
887+ visible = (int) maxMinusMin;
888+ }
889+ if (visible < 1) {
890+ visible = 1;
891+ }
892+
893+ if (value < minimum) {
894+ value = minimum;
895+ }
896+ if (value > maximum - visible) {
897+ value = maximum - visible;
898+ }
899+
900+ oldValue = this.value;
901+ this.value = value;
902+ this.visibleAmount = visible;
903+ this.minimum = minimum;
904+ this.maximum = maximum;
905+ ScrollbarPeer peer = (ScrollbarPeer)this.peer;
906+ if (peer != null) {
907+ peer.setValues(value, visibleAmount, minimum, maximum);
908+ }
909+ }
910+
911+ if ((oldValue != value) && (accessibleContext != null)) {
912+ accessibleContext.firePropertyChange(
913+ AccessibleContext.ACCESSIBLE_VALUE_PROPERTY,
914+ Integer.valueOf(oldValue),
915+ Integer.valueOf(value));
916+ }
917+ }
918+
919+ /**
920+ * Returns true if the value is in the process of changing as a
921+ * result of actions being taken by the user.
922+ *
923+ * @return the value of the <code>valueIsAdjusting</code> property
924+ * @see #setValueIsAdjusting
925+ * @since 1.4
926+ */
927+ public boolean getValueIsAdjusting() {
928+ return isAdjusting;
929+ }
930+
931+ /**
932+ * Sets the <code>valueIsAdjusting</code> property.
933+ *
934+ * @param b new adjustment-in-progress status
935+ * @see #getValueIsAdjusting
936+ * @since 1.4
937+ */
938+ public void setValueIsAdjusting(boolean b) {
939+ boolean oldValue;
940+
941+ synchronized (this) {
942+ oldValue = isAdjusting;
943+ isAdjusting = b;
944+ }
945+
946+ if ((oldValue != b) && (accessibleContext != null)) {
947+ accessibleContext.firePropertyChange(
948+ AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
949+ ((oldValue) ? AccessibleState.BUSY : null),
950+ ((b) ? AccessibleState.BUSY : null));
951+ }
952+ }
953+
954+
955+
956+ /**
957+ * Adds the specified adjustment listener to receive instances of
958+ * <code>AdjustmentEvent</code> from this scroll bar.
959+ * If l is <code>null</code>, no exception is thrown and no
960+ * action is performed.
961+ * <p>Refer to <a href="doc-files/AWTThreadIssues.html#ListenersThreads"
962+ * >AWT Threading Issues</a> for details on AWT's threading model.
963+ *
964+ * @param l the adjustment listener
965+ * @see #removeAdjustmentListener
966+ * @see #getAdjustmentListeners
967+ * @see java.awt.event.AdjustmentEvent
968+ * @see java.awt.event.AdjustmentListener
969+ * @since JDK1.1
970+ */
971+ public synchronized void addAdjustmentListener(AdjustmentListener l) {
972+ if (l == null) {
973+ return;
974+ }
975+ adjustmentListener = AWTEventMulticaster.add(adjustmentListener, l);
976+ newEventsOnly = true;
977+ }
978+
979+ /**
980+ * Removes the specified adjustment listener so that it no longer
981+ * receives instances of <code>AdjustmentEvent</code> from this scroll bar.
982+ * If l is <code>null</code>, no exception is thrown and no action
983+ * is performed.
984+ * <p>Refer to <a href="doc-files/AWTThreadIssues.html#ListenersThreads"
985+ * >AWT Threading Issues</a> for details on AWT's threading model.
986+ *
987+ * @param l the adjustment listener
988+ * @see #addAdjustmentListener
989+ * @see #getAdjustmentListeners
990+ * @see java.awt.event.AdjustmentEvent
991+ * @see java.awt.event.AdjustmentListener
992+ * @since JDK1.1
993+ */
994+ public synchronized void removeAdjustmentListener(AdjustmentListener l) {
995+ if (l == null) {
996+ return;
997+ }
998+ adjustmentListener = AWTEventMulticaster.remove(adjustmentListener, l);
999+ }
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(Class<T> listenerType) {
1049+ EventListener l = null;
1050+ if (listenerType == AdjustmentListener.class) {
1051+ l = adjustmentListener;
1052+ } else {
1053+ return super.getListeners(listenerType);
1054+ }
1055+ return AWTEventMulticaster.getListeners(l, listenerType);
1056+ }
1057+
1058+ // REMIND: remove when filtering is done at lower level
1059+ boolean eventEnabled(AWTEvent e) {
1060+ if (e.id == AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED) {
1061+ if ((eventMask & AWTEvent.ADJUSTMENT_EVENT_MASK) != 0 ||
1062+ adjustmentListener != null) {
1063+ return true;
1064+ }
1065+ return false;
1066+ }
1067+ return super.eventEnabled(e);
1068+ }
1069+
1070+ /**
1071+ * Processes events on this scroll bar. If the event is an
1072+ * instance of <code>AdjustmentEvent</code>, it invokes the
1073+ * <code>processAdjustmentEvent</code> method.
1074+ * Otherwise, it invokes its superclass's
1075+ * <code>processEvent</code> method.
1076+ * <p>Note that if the event parameter is <code>null</code>
1077+ * the behavior is unspecified and may result in an
1078+ * exception.
1079+ *
1080+ * @param e the event
1081+ * @see java.awt.event.AdjustmentEvent
1082+ * @see java.awt.Scrollbar#processAdjustmentEvent
1083+ * @since JDK1.1
1084+ */
1085+ protected void processEvent(AWTEvent e) {
1086+ if (e instanceof AdjustmentEvent) {
1087+ processAdjustmentEvent((AdjustmentEvent)e);
1088+ return;
1089+ }
1090+ super.processEvent(e);
1091+ }
1092+
1093+ /**
1094+ * Processes adjustment events occurring on this
1095+ * scrollbar by dispatching them to any registered
1096+ * <code>AdjustmentListener</code> objects.
1097+ * <p>
1098+ * This method is not called unless adjustment events are
1099+ * enabled for this component. Adjustment events are enabled
1100+ * when one of the following occurs:
1101+ * <p><ul>
1102+ * <li>An <code>AdjustmentListener</code> object is registered
1103+ * via <code>addAdjustmentListener</code>.
1104+ * <li>Adjustment events are enabled via <code>enableEvents</code>.
1105+ * </ul><p>
1106+ * <p>Note that if the event parameter is <code>null</code>
1107+ * the behavior is unspecified and may result in an
1108+ * exception.
1109+ *
1110+ * @param e the adjustment event
1111+ * @see java.awt.event.AdjustmentEvent
1112+ * @see java.awt.event.AdjustmentListener
1113+ * @see java.awt.Scrollbar#addAdjustmentListener
1114+ * @see java.awt.Component#enableEvents
1115+ * @since JDK1.1
1116+ */
1117+ protected void processAdjustmentEvent(AdjustmentEvent e) {
1118+ AdjustmentListener listener = adjustmentListener;
1119+ if (listener != null) {
1120+ listener.adjustmentValueChanged(e);
1121+ }
1122+ }
1123+
1124+ /**
1125+ * Returns a string representing the state of this <code>Scrollbar</code>.
1126+ * This method is intended to be used only for debugging purposes, and the
1127+ * content and format of the returned string may vary between
1128+ * implementations. The returned string may be empty but may not be
1129+ * <code>null</code>.
1130+ *
1131+ * @return the parameter string of this scroll bar
1132+ */
1133+ protected String paramString() {
1134+ return super.paramString() +
1135+ ",val=" + value +
1136+ ",vis=" + visibleAmount +
1137+ ",min=" + minimum +
1138+ ",max=" + maximum +
1139+ ((orientation == VERTICAL) ? ",vert" : ",horz") +
1140+ ",isAdjusting=" + isAdjusting;
1141+ }
1142+
1143+
1144+ /* Serialization support.
1145+ */
1146+
1147+ /**
1148+ * The scroll bar's serialized Data Version.
1149+ *
1150+ * @serial
1151+ */
1152+ private int scrollbarSerializedDataVersion = 1;
1153+
1154+ /**
1155+ * Writes default serializable fields to stream. Writes
1156+ * a list of serializable <code>AdjustmentListeners</code>
1157+ * as optional data. The non-serializable listeners are
1158+ * detected and no attempt is made to serialize them.
1159+ *
1160+ * @param s the <code>ObjectOutputStream</code> to write
1161+ * @serialData <code>null</code> terminated sequence of 0
1162+ * or more pairs; the pair consists of a <code>String</code>
1163+ * and an <code>Object</code>; the <code>String</code> indicates
1164+ * the type of object and is one of the following:
1165+ * <code>adjustmentListenerK</code> indicating an
1166+ * <code>AdjustmentListener</code> object
1167+ *
1168+ * @see AWTEventMulticaster#save(ObjectOutputStream, String, EventListener)
1169+ * @see java.awt.Component#adjustmentListenerK
1170+ * @see #readObject(ObjectInputStream)
1171+ */
1172+ private void writeObject(ObjectOutputStream s)
1173+ throws IOException
1174+ {
1175+ s.defaultWriteObject();
1176+
1177+ AWTEventMulticaster.save(s, adjustmentListenerK, adjustmentListener);
1178+ s.writeObject(null);
1179+ }
1180+
1181+ /**
1182+ * Reads the <code>ObjectInputStream</code> and if
1183+ * it isn't <code>null</code> adds a listener to
1184+ * receive adjustment events fired by the
1185+ * <code>Scrollbar</code>.
1186+ * Unrecognized keys or values will be ignored.
1187+ *
1188+ * @param s the <code>ObjectInputStream</code> to read
1189+ * @exception HeadlessException if
1190+ * <code>GraphicsEnvironment.isHeadless</code> returns
1191+ * <code>true</code>
1192+ * @see java.awt.GraphicsEnvironment#isHeadless
1193+ * @see #writeObject(ObjectOutputStream)
1194+ */
1195+ private void readObject(ObjectInputStream s)
1196+ throws ClassNotFoundException, IOException, HeadlessException
1197+ {
1198+ GraphicsEnvironment.checkHeadless();
1199+ s.defaultReadObject();
1200+
1201+ Object keyOrNull;
1202+ while(null != (keyOrNull = s.readObject())) {
1203+ String key = ((String)keyOrNull).intern();
1204+
1205+ if (adjustmentListenerK == key)
1206+ addAdjustmentListener((AdjustmentListener)(s.readObject()));
1207+
1208+ else // skip value for unrecognized key
1209+ s.readObject();
1210+ }
1211+ }
1212+
1213+
1214+/////////////////
1215+// Accessibility support
1216+////////////////
1217+
1218+ /**
1219+ * Gets the <code>AccessibleContext</code> associated with this
1220+ * <code>Scrollbar</code>. For scrollbars, the
1221+ * <code>AccessibleContext</code> takes the form of an
1222+ * <code>AccessibleAWTScrollBar</code>. A new
1223+ * <code>AccessibleAWTScrollBar</code> instance is created if necessary.
1224+ *
1225+ * @return an <code>AccessibleAWTScrollBar</code> that serves as the
1226+ * <code>AccessibleContext</code> of this <code>ScrollBar</code>
1227+ * @since 1.3
1228+ */
1229+ public AccessibleContext getAccessibleContext() {
1230+ if (accessibleContext == null) {
1231+ accessibleContext = new AccessibleAWTScrollBar();
1232+ }
1233+ return accessibleContext;
1234+ }
1235+
1236+ /**
1237+ * This class implements accessibility support for the
1238+ * <code>Scrollbar</code> class. It provides an implementation of
1239+ * the Java Accessibility API appropriate to scrollbar
1240+ * user-interface elements.
1241+ * @since 1.3
1242+ */
1243+ protected class AccessibleAWTScrollBar extends AccessibleAWTComponent
1244+ implements AccessibleValue
1245+ {
1246+ /*
1247+ * JDK 1.3 serialVersionUID
1248+ */
1249+ private static final long serialVersionUID = -344337268523697807L;
1250+
1251+ /**
1252+ * Get the state set of this object.
1253+ *
1254+ * @return an instance of <code>AccessibleState</code>
1255+ * containing the current state of the object
1256+ * @see AccessibleState
1257+ */
1258+ public AccessibleStateSet getAccessibleStateSet() {
1259+ AccessibleStateSet states = super.getAccessibleStateSet();
1260+ if (getValueIsAdjusting()) {
1261+ states.add(AccessibleState.BUSY);
1262+ }
1263+ if (getOrientation() == VERTICAL) {
1264+ states.add(AccessibleState.VERTICAL);
1265+ } else {
1266+ states.add(AccessibleState.HORIZONTAL);
1267+ }
1268+ return states;
1269+ }
1270+
1271+ /**
1272+ * Get the role of this object.
1273+ *
1274+ * @return an instance of <code>AccessibleRole</code>
1275+ * describing the role of the object
1276+ */
1277+ public AccessibleRole getAccessibleRole() {
1278+ return AccessibleRole.SCROLL_BAR;
1279+ }
1280+
1281+ /**
1282+ * Get the <code>AccessibleValue</code> associated with this
1283+ * object. In the implementation of the Java Accessibility
1284+ * API for this class, return this object, which is
1285+ * responsible for implementing the
1286+ * <code>AccessibleValue</code> interface on behalf of itself.
1287+ *
1288+ * @return this object
1289+ */
1290+ public AccessibleValue getAccessibleValue() {
1291+ return this;
1292+ }
1293+
1294+ /**
1295+ * Get the accessible value of this object.
1296+ *
1297+ * @return The current value of this object.
1298+ */
1299+ public Number getCurrentAccessibleValue() {
1300+ return Integer.valueOf(getValue());
1301+ }
1302+
1303+ /**
1304+ * Set the value of this object as a Number.
1305+ *
1306+ * @return True if the value was set.
1307+ */
1308+ public boolean setCurrentAccessibleValue(Number n) {
1309+ if (n instanceof Integer) {
1310+ setValue(n.intValue());
1311+ return true;
1312+ } else {
1313+ return false;
1314+ }
1315+ }
1316+
1317+ /**
1318+ * Get the minimum accessible value of this object.
1319+ *
1320+ * @return The minimum value of this object.
1321+ */
1322+ public Number getMinimumAccessibleValue() {
1323+ return Integer.valueOf(getMinimum());
1324+ }
1325+
1326+ /**
1327+ * Get the maximum accessible value of this object.
1328+ *
1329+ * @return The maximum value of this object.
1330+ */
1331+ public Number getMaximumAccessibleValue() {
1332+ return Integer.valueOf(getMaximum());
1333+ }
1334+
1335+ } // AccessibleAWTScrollBar
1336+
1337+}