Source for javax.swing.SizeSequence

   1: /* SizeSequence.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., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 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: /**
  41:  * SizeSequence
  42:  * @author    Andrew Selkirk
  43:  * @version    1.0
  44:  */
  45: public class SizeSequence {
  46: 
  47:     //-------------------------------------------------------------
  48:     // Variables --------------------------------------------------
  49:     //-------------------------------------------------------------
  50: 
  51:     /**
  52:      * sizes
  53:      */
  54:     private int[] sizes = new int[0];
  55: 
  56: 
  57:     //-------------------------------------------------------------
  58:     // Initialization ---------------------------------------------
  59:     //-------------------------------------------------------------
  60: 
  61:     /**
  62:      * Constructor SizeSequence
  63:      */
  64:     public SizeSequence() {
  65:         sizes = new int[0];
  66:     } // SizeSequence()
  67: 
  68:     /**
  69:      * Constructor SizeSequence
  70:      * @param numEntries TODO
  71:      */
  72:     public SizeSequence(int numEntries) {
  73:         this(numEntries, 0);
  74:     } // SizeSequence()
  75: 
  76:     /**
  77:      * Constructor SizeSequence
  78:      * @param numEntries TODO
  79:      * @param value TODO
  80:      */
  81:     public SizeSequence(int numEntries, int value) {
  82:         insertEntries(0, numEntries, value);
  83:     } // SizeSequence()
  84: 
  85:     /**
  86:      * Constructor SizeSequence
  87:      * @param sizes TODO
  88:      */
  89:     public SizeSequence(int[] sizes) {
  90:         setSizes(sizes);
  91:     } // SizeSequence()
  92: 
  93: 
  94:     //-------------------------------------------------------------
  95:     // Methods ----------------------------------------------------
  96:     //-------------------------------------------------------------
  97: 
  98:     /**
  99:      * setSize
 100:      * @param index TODO
 101:      * @param size TODO
 102:      */
 103:     public void setSize(int index, int size) {
 104:         sizes[index] = size;
 105:     } // setSize()
 106: 
 107:     /**
 108:      * getIndex
 109:      * @param position TODO
 110:      * @returns int
 111:      */
 112:     public int getIndex(int position) {
 113:         return 0; // TODO
 114:     } // getIndex()
 115: 
 116:     /**
 117:      * getSize
 118:      * @param index TODO
 119:      * @returns int
 120:      */
 121:     public int getSize(int index) {
 122:         return sizes[index];
 123:     } // getSize()
 124: 
 125:     /**
 126:      * setSizes
 127:      * @param sizes TODO
 128:      */
 129:     public void setSizes(int[] sizes) {
 130:     
 131:         // Variables
 132:         int        index;
 133:         
 134:         // Initialize Sizes
 135:         this.sizes = new int[sizes.length];
 136:         for (index = 0; index < sizes.length; index++) {
 137:             this.sizes[index] = sizes[index];
 138:         } // for
 139: 
 140:     } // setSizes()
 141: 
 142:     /**
 143:      * getSizes
 144:      * @returns int[]
 145:      */
 146:     public int[] getSizes() {
 147:     
 148:         // Variables
 149:         int[]    array;
 150:         int        index;
 151: 
 152:         // Create New Array
 153:         array = new int[sizes.length];
 154:         for (index = 0; index < sizes.length; index++) {
 155:             array[index] = sizes[index];
 156:         } // for
 157: 
 158:         // Return Newly created array
 159:         return array;
 160: 
 161:     } // getSizes()
 162: 
 163:     /**
 164:      * getPosition
 165:      * @param index TODO
 166:      * @returns int
 167:      */
 168:     public int getPosition(int index) {
 169:     
 170:         // Variables
 171:         int        position;
 172:         int        loop;
 173:         
 174:         // Process Sizes
 175:         position = 0;
 176:         for (loop = 0; loop < index; loop++) {
 177:             position += sizes[loop];
 178:         } // for
 179: 
 180:         // Return Position
 181:         return position;
 182: 
 183:     } // getPosition()
 184: 
 185:     /**
 186:      * insertEntries
 187:      * @param start TODO
 188:      * @param length TODO
 189:      * @param value TODO
 190:      */
 191:     public void insertEntries(int start, int length, int value) {
 192: 
 193:         // Variables
 194:         int[]    array;
 195:         int        index;
 196:         int        arrayIndex;
 197:         int        loop;
 198: 
 199:         // Create New Array
 200:         array = new int[sizes.length + length];
 201:         arrayIndex = 0;
 202:         for (index = 0; index < sizes.length; index++) {
 203:             if (index == start) {
 204:                 for (loop = 0; loop < length; loop++) {
 205:                     array[arrayIndex] = value;
 206:                     arrayIndex++;
 207:                 } // for
 208:             } else {
 209:                 array[arrayIndex] = sizes[index];
 210:                 arrayIndex++;
 211:             } // if
 212:         } // for
 213: 
 214:     } // insertEntries()
 215: 
 216:     /**
 217:      * removeEntries
 218:      * @param start TODO
 219:      * @param length TODO
 220:      */
 221:     public void removeEntries(int start, int length) {
 222: 
 223:         // Variables
 224:         int[]    array;
 225:         int        index;
 226:         int        arrayIndex;
 227: 
 228:         // Sanity Check
 229:         if ((start + length) > sizes.length) {
 230:             throw new IllegalArgumentException("Specified start/length that " +
 231:                 "is greater than available sizes");
 232:         } // if
 233: 
 234:         // Create New Array
 235:         array = new int[sizes.length - length];
 236:         arrayIndex = 0;
 237:         for (index = 0; index < sizes.length; index++) {
 238:             if (index == start) {
 239:                 index += length - 1;
 240:             } else {
 241:                 array[arrayIndex] = sizes[index];
 242:                 arrayIndex++;
 243:             } // if
 244:         } // for
 245: 
 246:     } // removeEntries()
 247: 
 248: 
 249: } // SizeSequence