1 /*

     2  * Copyright 1997-2006 Sun Microsystems, Inc.  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.  Sun designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any questions.

    24  */

    25 

    26 package javax.swing;

    27 

    28 import javax.swing.event.*;

    29 import java.io.Serializable;

    30 import java.util.EventListener;

    31 

    32 /**

    33  * A generic implementation of BoundedRangeModel.

    34  * <p>

    35  * <strong>Warning:</strong>

    36  * Serialized objects of this class will not be compatible with

    37  * future Swing releases. The current serialization support is

    38  * appropriate for short term storage or RMI between applications running

    39  * the same version of Swing.  As of 1.4, support for long term storage

    40  * of all JavaBeans<sup><font size="-2">TM</font></sup>

    41  * has been added to the <code>java.beans</code> package.

    42  * Please see {@link java.beans.XMLEncoder}.

    43  *

    44  * @author David Kloba

    45  * @author Hans Muller

    46  * @see BoundedRangeModel

    47  */

    48 public class DefaultBoundedRangeModel implements BoundedRangeModel, Serializable

    49 {

    50     /**

    51      * Only one <code>ChangeEvent</code> is needed per model instance since the

    52      * event's only (read-only) state is the source property.  The source

    53      * of events generated here is always "this".

    54      */

    55     protected transient ChangeEvent changeEvent = null;

    56 

    57     /** The listeners waiting for model changes. */

    58     protected EventListenerList listenerList = new EventListenerList();

    59 

    60     private int value = 0;

    61     private int extent = 0;

    62     private int min = 0;

    63     private int max = 100;

    64     private boolean isAdjusting = false;

    65 

    66 

    67     /**

    68      * Initializes all of the properties with default values.

    69      * Those values are:

    70      * <ul>

    71      * <li><code>value</code> = 0

    72      * <li><code>extent</code> = 0

    73      * <li><code>minimum</code> = 0

    74      * <li><code>maximum</code> = 100

    75      * <li><code>adjusting</code> = false

    76      * </ul>

    77      */

    78     public DefaultBoundedRangeModel() {

    79     }

    80 

    81 

    82     /**

    83      * Initializes value, extent, minimum and maximum. Adjusting is false.

    84      * Throws an <code>IllegalArgumentException</code> if the following

    85      * constraints aren't satisfied:

    86      * <pre>

    87      * min <= value <= value+extent <= max

    88      * </pre>

    89      */

    90     public DefaultBoundedRangeModel(int value, int extent, int min, int max)

    91     {

    92         if ((max >= min) &&

    93             (value >= min) &&

    94             ((value + extent) >= value) &&

    95             ((value + extent) <= max)) {

    96             this.value = value;

    97             this.extent = extent;

    98             this.min = min;

    99             this.max = max;

   100         }

   101         else {

   102             throw new IllegalArgumentException("invalid range properties");

   103         }

   104     }

   105 

   106 

   107     /**

   108      * Returns the model's current value.

   109      * @return the model's current value

   110      * @see #setValue

   111      * @see BoundedRangeModel#getValue

   112      */

   113     public int getValue() {

   114       return value;

   115     }

   116 

   117 

   118     /**

   119      * Returns the model's extent.

   120      * @return the model's extent

   121      * @see #setExtent

   122      * @see BoundedRangeModel#getExtent

   123      */

   124     public int getExtent() {

   125       return extent;

   126     }

   127 

   128 

   129     /**

   130      * Returns the model's minimum.

   131      * @return the model's minimum

   132      * @see #setMinimum

   133      * @see BoundedRangeModel#getMinimum

   134      */

   135     public int getMinimum() {

   136       return min;

   137     }

   138 

   139 

   140     /**

   141      * Returns the model's maximum.

   142      * @return  the model's maximum

   143      * @see #setMaximum

   144      * @see BoundedRangeModel#getMaximum

   145      */

   146     public int getMaximum() {

   147         return max;

   148     }

   149 

   150 

   151     /**

   152      * Sets the current value of the model. For a slider, that

   153      * determines where the knob appears. Ensures that the new

   154      * value, <I>n</I> falls within the model's constraints:

   155      * <pre>

   156      *     minimum <= value <= value+extent <= maximum

   157      * </pre>

   158      *

   159      * @see BoundedRangeModel#setValue

   160      */

   161     public void setValue(int n) {

   162         n = Math.min(n, Integer.MAX_VALUE - extent);

   163 

   164         int newValue = Math.max(n, min);

   165         if (newValue + extent > max) {

   166             newValue = max - extent;

   167         }

   168         setRangeProperties(newValue, extent, min, max, isAdjusting);

   169     }

   170 

   171 

   172     /**

   173      * Sets the extent to <I>n</I> after ensuring that <I>n</I>

   174      * is greater than or equal to zero and falls within the model's

   175      * constraints:

   176      * <pre>

   177      *     minimum <= value <= value+extent <= maximum

   178      * </pre>

   179      * @see BoundedRangeModel#setExtent

   180      */

   181     public void setExtent(int n) {

   182         int newExtent = Math.max(0, n);

   183         if(value + newExtent > max) {

   184             newExtent = max - value;

   185         }

   186         setRangeProperties(value, newExtent, min, max, isAdjusting);

   187     }

   188 

   189 

   190     /**

   191      * Sets the minimum to <I>n</I> after ensuring that <I>n</I>

   192      * that the other three properties obey the model's constraints:

   193      * <pre>

   194      *     minimum <= value <= value+extent <= maximum

   195      * </pre>

   196      * @see #getMinimum

   197      * @see BoundedRangeModel#setMinimum

   198      */

   199     public void setMinimum(int n) {

   200         int newMax = Math.max(n, max);

   201         int newValue = Math.max(n, value);

   202         int newExtent = Math.min(newMax - newValue, extent);

   203         setRangeProperties(newValue, newExtent, n, newMax, isAdjusting);

   204     }

   205 

   206 

   207     /**

   208      * Sets the maximum to <I>n</I> after ensuring that <I>n</I>

   209      * that the other three properties obey the model's constraints:

   210      * <pre>

   211      *     minimum <= value <= value+extent <= maximum

   212      * </pre>

   213      * @see BoundedRangeModel#setMaximum

   214      */

   215     public void setMaximum(int n) {

   216         int newMin = Math.min(n, min);

   217         int newExtent = Math.min(n - newMin, extent);

   218         int newValue = Math.min(n - newExtent, value);

   219         setRangeProperties(newValue, newExtent, newMin, n, isAdjusting);

   220     }

   221 

   222 

   223     /**

   224      * Sets the <code>valueIsAdjusting</code> property.

   225      *

   226      * @see #getValueIsAdjusting

   227      * @see #setValue

   228      * @see BoundedRangeModel#setValueIsAdjusting

   229      */

   230     public void setValueIsAdjusting(boolean b) {

   231         setRangeProperties(value, extent, min, max, b);

   232     }

   233 

   234 

   235     /**

   236      * Returns true if the value is in the process of changing

   237      * as a result of actions being taken by the user.

   238      *

   239      * @return the value of the <code>valueIsAdjusting</code> property

   240      * @see #setValue

   241      * @see BoundedRangeModel#getValueIsAdjusting

   242      */

   243     public boolean getValueIsAdjusting() {

   244         return isAdjusting;

   245     }

   246 

   247 

   248     /**

   249      * Sets all of the <code>BoundedRangeModel</code> properties after forcing

   250      * the arguments to obey the usual constraints:

   251      * <pre>

   252      *     minimum <= value <= value+extent <= maximum

   253      * </pre>

   254      * <p>

   255      * At most, one <code>ChangeEvent</code> is generated.

   256      *

   257      * @see BoundedRangeModel#setRangeProperties

   258      * @see #setValue

   259      * @see #setExtent

   260      * @see #setMinimum

   261      * @see #setMaximum

   262      * @see #setValueIsAdjusting

   263      */

   264     public void setRangeProperties(int newValue, int newExtent, int newMin, int newMax, boolean adjusting)

   265     {

   266         if (newMin > newMax) {

   267             newMin = newMax;

   268         }

   269         if (newValue > newMax) {

   270             newMax = newValue;

   271         }

   272         if (newValue < newMin) {

   273             newMin = newValue;

   274         }

   275 

   276         /* Convert the addends to long so that extent can be

   277          * Integer.MAX_VALUE without rolling over the sum.

   278          * A JCK test covers this, see bug 4097718.

   279          */

   280         if (((long)newExtent + (long)newValue) > newMax) {

   281             newExtent = newMax - newValue;

   282         }

   283 

   284         if (newExtent < 0) {

   285             newExtent = 0;

   286         }

   287 

   288         boolean isChange =

   289             (newValue != value) ||

   290             (newExtent != extent) ||

   291             (newMin != min) ||

   292             (newMax != max) ||

   293             (adjusting != isAdjusting);

   294 

   295         if (isChange) {

   296             value = newValue;

   297             extent = newExtent;

   298             min = newMin;

   299             max = newMax;

   300             isAdjusting = adjusting;

   301 

   302             fireStateChanged();

   303         }

   304     }

   305 

   306 

   307     /**

   308      * Adds a <code>ChangeListener</code>.  The change listeners are run each

   309      * time any one of the Bounded Range model properties changes.

   310      *

   311      * @param l the ChangeListener to add

   312      * @see #removeChangeListener

   313      * @see BoundedRangeModel#addChangeListener

   314      */

   315     public void addChangeListener(ChangeListener l) {

   316         listenerList.add(ChangeListener.class, l);

   317     }

   318 

   319 

   320     /**

   321      * Removes a <code>ChangeListener</code>.

   322      *

   323      * @param l the <code>ChangeListener</code> to remove

   324      * @see #addChangeListener

   325      * @see BoundedRangeModel#removeChangeListener

   326      */

   327     public void removeChangeListener(ChangeListener l) {

   328         listenerList.remove(ChangeListener.class, l);

   329     }

   330 

   331 

   332     /**

   333      * Returns an array of all the change listeners

   334      * registered on this <code>DefaultBoundedRangeModel</code>.

   335      *

   336      * @return all of this model's <code>ChangeListener</code>s

   337      *         or an empty

   338      *         array if no change listeners are currently registered

   339      *

   340      * @see #addChangeListener

   341      * @see #removeChangeListener

   342      *

   343      * @since 1.4

   344      */

   345     public ChangeListener[] getChangeListeners() {

   346         return (ChangeListener[])listenerList.getListeners(

   347                 ChangeListener.class);

   348     }

   349 

   350 

   351     /**

   352      * Runs each <code>ChangeListener</code>'s <code>stateChanged</code> method.

   353      *

   354      * @see #setRangeProperties

   355      * @see EventListenerList

   356      */

   357     protected void fireStateChanged()

   358     {

   359         Object[] listeners = listenerList.getListenerList();

   360         for (int i = listeners.length - 2; i >= 0; i -=2 ) {

   361             if (listeners[i] == ChangeListener.class) {

   362                 if (changeEvent == null) {

   363                     changeEvent = new ChangeEvent(this);

   364                 }

   365                 ((ChangeListener)listeners[i+1]).stateChanged(changeEvent);

   366             }

   367         }

   368     }

   369 

   370 

   371     /**

   372      * Returns a string that displays all of the

   373      * <code>BoundedRangeModel</code> properties.

   374      */

   375     public String toString()  {

   376         String modelString =

   377             "value=" + getValue() + ", " +

   378             "extent=" + getExtent() + ", " +

   379             "min=" + getMinimum() + ", " +

   380             "max=" + getMaximum() + ", " +

   381             "adj=" + getValueIsAdjusting();

   382 

   383         return getClass().getName() + "[" + modelString + "]";

   384     }

   385 

   386     /**

   387      * Returns an array of all the objects currently registered as

   388      * <code><em>Foo</em>Listener</code>s

   389      * upon this model.

   390      * <code><em>Foo</em>Listener</code>s

   391      * are registered using the <code>add<em>Foo</em>Listener</code> method.

   392      * <p>

   393      * You can specify the <code>listenerType</code> argument

   394      * with a class literal, such as <code><em>Foo</em>Listener.class</code>.

   395      * For example, you can query a <code>DefaultBoundedRangeModel</code>

   396      * instance <code>m</code>

   397      * for its change listeners

   398      * with the following code:

   399      *

   400      * <pre>ChangeListener[] cls = (ChangeListener[])(m.getListeners(ChangeListener.class));</pre>

   401      *

   402      * If no such listeners exist,

   403      * this method returns an empty array.

   404      *

   405      * @param listenerType  the type of listeners requested;

   406      *          this parameter should specify an interface

   407      *          that descends from <code>java.util.EventListener</code>

   408      * @return an array of all objects registered as

   409      *          <code><em>Foo</em>Listener</code>s

   410      *          on this model,

   411      *          or an empty array if no such

   412      *          listeners have been added

   413      * @exception ClassCastException if <code>listenerType</code> doesn't

   414      *          specify a class or interface that implements

   415      *          <code>java.util.EventListener</code>

   416      *

   417      * @see #getChangeListeners

   418      *

   419      * @since 1.3

   420      */

   421     public <T extends EventListener> T[] getListeners(Class<T> listenerType) {

   422         return listenerList.getListeners(listenerType);

   423     }

   424 }