/[classpath]/classpath/javax/swing/SizeSequence.java
ViewVC logotype

Diff of /classpath/javax/swing/SizeSequence.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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

Legend:
Removed from v.1.2  
changed lines
  Added in v.1.3

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26