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 // Imports
  41 import java.io.*;
  42 import java.util.*;
  43 import javax.swing.event.*;
  44
  45 /**
  46  * DefaultBoundedRangeModel
  47  * @author      Andrew Selkirk
  48  * @version     1.0
  49  */
  50 public class DefaultBoundedRangeModel implements BoundedRangeModel, Serializable {
  51
  52         //-------------------------------------------------------------
  53         // Variables --------------------------------------------------
  54         //-------------------------------------------------------------
  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         //-------------------------------------------------------------
  93         // Initialization ---------------------------------------------
  94         //-------------------------------------------------------------
  95
  96         /**
  97          * Constructor DefaultBoundedRangeModel
  98          */
  99         public DefaultBoundedRangeModel() {
 100                 setRangeProperties(0, 0, 0, 100, false);
 101         } // DefaultBoundedRangeModel()
 102
 103         /**
 104          * Constructor DefaultBoundedRangeModel
 105          * @param value TODO
 106          * @param extent TODO
 107          * @param minimum TODO
 108          * @param maximum TODO
 109          */
 110         public DefaultBoundedRangeModel(int value, int extent,
 111                                 int minimum, int maximum) {
 112                 setRangeProperties(value, extent, minimum, maximum, false);
 113         } // DefaultBoundedRangeModel()
 114
 115
 116         //-------------------------------------------------------------
 117         // Methods ----------------------------------------------------
 118         //-------------------------------------------------------------
 119
 120         /**
 121          * toString
 122          * @returns String
 123          */
 124         public String toString() {
 125                 return null; // TODO
 126         } // toString()
 127
 128         /**
 129          * getValue
 130          * @returns int
 131          */
 132         public int getValue() {
 133                 return value;
 134         } // getValue()
 135
 136         /**
 137          * setValue
 138          * @param value TODO
 139          */
 140         public void setValue(int value) {
 141
 142                 // Validate Constraints
 143                 if (minimum > value || value > (value + extent) ||
 144                         (value + extent) > maximum) {
 145                         throw new IllegalArgumentException("Invalid value property set");
 146                 } // if
 147
 148                 // Set Value
 149                 this.value = value;
 150
 151                 // Notification
 152                 fireStateChanged();
 153
 154         } // setValue()
 155
 156         /**
 157          * getExtent
 158          * @returns int
 159          */
 160         public int getExtent() {
 161                 return extent;
 162         } // getExtent()
 163
 164         /**
 165          * setExtent
 166          * @param extent TODO
 167          */
 168         public void setExtent(int extent) {
 169
 170                 // Validate Constraints
 171                 if (minimum > value || value > (value + extent) ||
 172                         (value + extent) > maximum) {
 173                         throw new IllegalArgumentException("Invalid extent property set");
 174                 } // if
 175
 176                 // Set Extent
 177                 this.extent = extent;
 178
 179                 // Notification
 180                 fireStateChanged();
 181
 182         } // setExtent()
 183
 184         /**
 185          * getMinimum
 186          * @returns int
 187          */
 188         public int getMinimum() {
 189                 return minimum;
 190         } // getMinimum()
 191
 192         /**
 193          * setMinimum
 194          * @param minimum TODO
 195          */
 196         public void setMinimum(int minimum) {
 197
 198                 // Validate Constraints
 199                 if (minimum > value || value > (value + extent) ||
 200                         (value + extent) > maximum) {
 201                         throw new IllegalArgumentException("Invalid minimum property set");
 202                 } // if
 203
 204                 // Set Minimum
 205                 this.minimum = minimum;
 206
 207                 // Notification
 208                 fireStateChanged();
 209
 210         } // setMinimum()
 211
 212         /**
 213          * getMaximum
 214          * @returns int
 215          */
 216         public int getMaximum() {
 217                 return maximum;
 218         } // getMaximum()
 219
 220         /**
 221          * setMaximum
 222          * @param maximum TODO
 223          */
 224         public void setMaximum(int maximum) {
 225
 226                 // Validate Constraints
 227                 if (minimum > value || value > (value + extent) ||
 228                         (value + extent) > maximum) {
 229                         throw new IllegalArgumentException("Invalid maximum property set");
 230                 } // if
 231
 232                 // Set Maximum
 233                 this.maximum = maximum;
 234
 235                 // Notification
 236                 fireStateChanged();
 237
 238         } // setMaximum()
 239
 240         /**
 241          * getValueIsAdjusting
 242          * @returns boolean
 243          */
 244         public boolean getValueIsAdjusting() {
 245                 return isAdjusting;
 246         } // getValueIsAdjusting()
 247
 248         /**
 249          * setValueIsAdjusting
 250          * @param isAdjusting TODO
 251          */
 252         public void setValueIsAdjusting(boolean isAdjusting) {
 253
 254                 // Set isAdjusting
 255                 this.isAdjusting = isAdjusting;
 256
 257                 // Notification
 258                 fireStateChanged();
 259
 260         } // setValueIsAdjusting()
 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 || value > (value + extent) ||
 275                         (value + extent) > maximum) {
 276                         throw new IllegalArgumentException("Invalid property set");
 277                 } // if
 278
 279                 // Set Data
 280                 this.value = value;
 281                 this.extent = extent;
 282                 this.minimum = minimum;
 283                 this.maximum = maximum;
 284                 this.isAdjusting = isAdjusting;
 285
 286                 // Notification
 287                 fireStateChanged();
 288
 289         } // setRangeProperties()
 290
 291         /**
 292          * addChangeListener
 293          * @param listener TODO
 294          */
 295         public void addChangeListener(ChangeListener listener) {
 296                 listenerList.add(ChangeListener.class, listener);
 297         } // addChangeListener()
 298
 299         /**
 300          * removeChangeListener
 301          * @param listener TODO
 302          */
 303         public void removeChangeListener(ChangeListener listener) {
 304                 listenerList.remove(ChangeListener.class, listener);
 305         } // removeChangeListener()
 306
 307         /**
 308          * fireStateChanged
 309          */
 310         protected void fireStateChanged() {
 311
 312                 // Variables
 313                 ChangeListener                  listener;
 314                 EventListener[]                 listeners;
 315                 int                                             index;
 316
 317                 // Get Listeners
 318                 listeners = listenerList.getListeners(ChangeListener.class);
 319
 320                 // Process Listeners
 321                 for (index = 0; index < listeners.length; index++) {
 322                         listener = (ChangeListener) listeners[index];
 323                         listener.stateChanged(changeEvent);
 324                 } // for
 325
 326         } // fireStateChanged()
 327
 328         /**
 329          * getListeners
 330          * @param c TODO
 331          * @returns EventListener[]
 332          */
 333         public EventListener[] getListeners(Class c) {
 334                 return listenerList.getListeners(c);
 335         } // getListeners()
 336
 337         /**
 338          * getChangeListeners
 339          */
 340         public ChangeListener[] getChangeListeners()
 341         {
 342           // FIXME: implement this
 343           return null;
 344         }
 345
 346
 347 } // DefaultBoundedRangeModel