libjava/javax/swing/DefaultBoundedRangeModel.java

   1 /* DefaultBoundedRangeModel.java --
   2    Copyright (C) 2002 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38 package javax.swing;
  39
  40 import java.io.Serializable;
  41 import java.util.EventListener;
  42 import javax.swing.event.ChangeEvent;
  43 import javax.swing.event.ChangeListener;
  44 import javax.swing.event.EventListenerList;
  45
  46 /**
  47  * DefaultBoundedRangeModel
  48  * @author      Andrew Selkirk
  49  * @version     1.0
  50  */
  51 public class DefaultBoundedRangeModel
  52   implements BoundedRangeModel, Serializable
  53 {
  54   static final long serialVersionUID = 5034068491295259790L;
  55
  56   /**
  57    * changeEvent
  58    */
  59   protected transient ChangeEvent changeEvent = new ChangeEvent (this);
  60
  61   /**
  62    * listenerList
  63    */
  64   protected EventListenerList listenerList = new EventListenerList ();
  65
  66   /**
  67    * value
  68    */
  69   private int value;
  70
  71   /**
  72    * extent
  73    */
  74   private int extent;
  75
  76   /**
  77    * minimum
  78    */
  79   private int minimum;
  80
  81   /**
  82    * maximum
  83    */
  84   private int maximum;
  85
  86   /**
  87    * isAdjusting
  88    */
  89   private boolean isAdjusting;
  90
  91   /**
  92    * Constructor DefaultBoundedRangeModel
  93    */
  94   public DefaultBoundedRangeModel ()
  95   {
  96     setRangeProperties (0, 0, 0, 100, false);
  97   }
  98
  99   /**
 100    * Constructor DefaultBoundedRangeModel
 101    * @param value TODO
 102    * @param extent TODO
 103    * @param minimum TODO
 104    * @param maximum TODO
 105    */
 106   public DefaultBoundedRangeModel (int value, int extent, int minimum,
 107                                   int maximum)
 108   {
 109     setRangeProperties(value, extent, minimum, maximum, false);
 110   }
 111
 112   /**
 113    * toString
 114    * @returns String
 115    */
 116   public String toString ()
 117   {
 118     return null; // TODO
 119   }
 120
 121   /**
 122    * getValue
 123    * @returns int
 124    */
 125   public int getValue ()
 126   {
 127     return value;
 128   }
 129
 130   /**
 131    * setValue
 132    * @param value TODO
 133    */
 134   public void setValue (int value)
 135   {
 136     // Validate Constraints
 137     if (minimum > value ||
 138         value > (value + extent) ||
 139         (value + extent) > maximum)
 140       {
 141         throw new IllegalArgumentException ("Invalid value property set");
 142       }
 143
 144     // Set Value
 145     this.value = value;
 146
 147     // Notification
 148     fireStateChanged ();
 149   }
 150
 151   /**
 152    * getExtent
 153    * @returns int
 154    */
 155   public int getExtent ()
 156   {
 157     return extent;
 158   }
 159
 160   /**
 161    * setExtent
 162    * @param extent TODO
 163    */
 164   public void setExtent (int extent)
 165   {
 166     // Validate Constraints
 167     if (minimum > value ||
 168         value > (value + extent) ||
 169         (value + extent) > maximum)
 170       {
 171         throw new IllegalArgumentException("Invalid extent property set");
 172       }
 173
 174     // Set Extent
 175     this.extent = extent;
 176
 177     // Notification
 178     fireStateChanged ();
 179   }
 180
 181   /**
 182    * getMinimum
 183    * @returns int
 184    */
 185   public int getMinimum ()
 186   {
 187     return minimum;
 188   }
 189
 190   /**
 191    * setMinimum
 192    * @param minimum TODO
 193    */
 194   public void setMinimum (int minimum)
 195   {
 196     // Validate Constraints
 197     if (minimum > value ||
 198         value > (value + extent) ||
 199         (value + extent) > maximum)
 200       {
 201         throw new IllegalArgumentException("Invalid minimum property set");
 202       }
 203
 204     // Set Minimum
 205     this.minimum = minimum;
 206
 207     // Notification
 208     fireStateChanged ();
 209   }
 210
 211   /**
 212    * getMaximum
 213    * @returns int
 214    */
 215   public int getMaximum() {
 216                 return maximum;
 217   }
 218
 219   /**
 220    * setMaximum
 221    * @param maximum TODO
 222    */
 223   public void setMaximum (int maximum)
 224   {
 225     // Validate Constraints
 226     if (minimum > value ||
 227         value > (value + extent) ||
 228         (value + extent) > maximum)
 229       {
 230         throw new IllegalArgumentException ("Invalid maximum property set");
 231       }
 232
 233     // Set Maximum
 234     this.maximum = maximum;
 235
 236     // Notification
 237     fireStateChanged ();
 238   }
 239
 240   /**
 241    * getValueIsAdjusting
 242    * @returns boolean
 243    */
 244   public boolean getValueIsAdjusting ()
 245   {
 246     return isAdjusting;
 247   }
 248
 249   /**
 250    * setValueIsAdjusting
 251    * @param isAdjusting TODO
 252    */
 253   public void setValueIsAdjusting (boolean isAdjusting)
 254   {
 255     // Set isAdjusting
 256     this.isAdjusting = isAdjusting;
 257
 258     // Notification
 259     fireStateChanged();
 260   }
 261
 262   /**
 263    * setRangeProperties
 264    * @param value TODO
 265    * @param extent TODO
 266    * @param minimum TODO
 267    * @param maximum TODO
 268    * @param isAdjusting TODO
 269    */
 270   public void setRangeProperties (int value, int extent, int minimum,
 271                                   int maximum, boolean isAdjusting)
 272   {
 273     // Validate Constraints
 274     if (minimum > value ||
 275         value > (value + extent) ||
 276         (value + extent) > maximum)
 277       {
 278         throw new IllegalArgumentException ("Invalid property set");
 279       }
 280
 281     // Set Data
 282     this.value = value;
 283     this.extent = extent;
 284     this.minimum = minimum;
 285     this.maximum = maximum;
 286     this.isAdjusting = isAdjusting;
 287
 288     // Notification
 289     fireStateChanged ();
 290   }
 291
 292   /**
 293    * addChangeListener
 294    * @param listener TODO
 295    */
 296   public void addChangeListener (ChangeListener listener)
 297   {
 298     listenerList.add (ChangeListener.class, listener);
 299   }
 300
 301   /**
 302    * removeChangeListener
 303    * @param listener TODO
 304    */
 305   public void removeChangeListener (ChangeListener listener)
 306   {
 307     listenerList.remove (ChangeListener.class, listener);
 308   }
 309
 310   /**
 311    * fireStateChanged
 312    */
 313   protected void fireStateChanged ()
 314   {
 315     // Variables
 316     ChangeListener listener;
 317     ChangeListener[] listeners;
 318     int index;
 319
 320     // Get Listeners
 321     listeners = getChangeListeners ();
 322
 323     // Process Listeners
 324     for (index = 0; index < listeners.length; index++)
 325     {
 326       listener = listeners [index];
 327       listener.stateChanged (changeEvent);
 328     }
 329   }
 330
 331   /**
 332    * getListeners
 333    * @param c TODO
 334    * @returns EventListener[]
 335    */
 336   public EventListener[] getListeners (Class listenerType)
 337   {
 338     return listenerList.getListeners (listenerType);
 339   }
 340
 341   /**
 342    * getChangeListeners
 343    */
 344   public ChangeListener[] getChangeListeners ()
 345   {
 346     return (ChangeListener[]) getListeners (ChangeListener.class);
 347   }
 348 }