Coverage Report

Coverage Report - net.wotonomy.ui.swing.components.NumericTextField

Classes in this File

3.556

 /*
 Wotonomy: OpenStep design patterns for pure Java applications.
 Copyright (C) 2000 Blacksmith, Inc
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.
 
 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, see http://www.gnu.org
 */
 
 package net.wotonomy.ui.swing.components;
 
 /**
 * NumericTextField is a "smart" text field that restricts the user's input.  The
 * input is restructed to numeric only wich can be of two types: integer and real
 * numbers.  A range can also be placed on the text field.  The default type is
 * integer, with the being (Integer.MIN_VALUE, Integer.MAX_VALUE).
 *
 * @author rob@straylight.princeton.com
 * @author $Author: cgruber $
 * @version $Revision: 893 $
 */
 public class NumericTextField extends SmartTextField
 {
 
 /*******************************
 * CONSTANTS
 *******************************/
 
 /**
 * Restrict the text input to integers (whole numbers) only.
 */
    public final static int INTEGER = 0;
 
 /**
 * Restrict the text input to floating-point numbers only.
 */
    public final static int FLOAT = 1;
 
    private Number maximumValue = null;
    private Number minimumValue = null;
 
    private boolean sign = false;
    private int newCaretPosition = 0;
    private int valueType = INTEGER;
 
 
 /*******************************
 * PUBLIC METHODS
 *******************************/
 
 /**
 * Default constructor.
 */
    public NumericTextField()
    {
       this("", 0);
    }
 
 /**
 * Constructor.
 * @param text The initial string the text field is set to.
 */
    public NumericTextField(String text)
    {
       this(text, 0);
    }
 
 /**
 * Constructor.
 * @param columns Width of the text field (in characters).
 */
    public NumericTextField(int columns)
    {
       this("", columns);
    }
 
 /**
 * Constructor.
 * @param text The initial string the text field is set to.
 * @param columns Width of the text field (in characters).
 */
    public NumericTextField(String text, int columns)
    {
       super(text, columns);
    }
 
 /**
 * Sets the upper limit of the range of numbers to accept.
 * @param newMaximumValue The maximum number accepted by the text field.
 */
    public void setMaximumValue(double newMaximumValue)
    {
       if (newMaximumValue >= 0)
       {
          maximumValue = new Double( newMaximumValue );
       }
       else
       {
          maximumValue = null;
       }
    }
 
 /**
 * Returns the upper limit of the range of numbers to accept.
 * @return The maximum number accepted by this text field.
 */
    public double getMaximumValue()
    {
       if ( valueType == INTEGER )
       {
         return (maximumValue == null) ? (double) Integer.MAX_VALUE : maximumValue.doubleValue();
       }
       else
       {
         return (maximumValue == null) ? Double.MAX_VALUE : maximumValue.doubleValue();
       }
    }
 
 /**
 * Sets the lower limit of the range of numbers to accept.
 * @param newMinimumValue The minimum number accepted by the text field.
 */
    public void setMinimumValue(double newMinimumValue)
    {
       if (newMinimumValue <= 0)
       {
          minimumValue  = new Double( newMinimumValue );
       }
       else
       {
          minimumValue = null;
       }
    }
 
 /**
 * Returns the lower limit of the range of numbers to accept.
 * @return The minimum number accepted by this text field.
 */
    public double getMinimumValue()
    {
       if ( valueType == INTEGER )
       {
         return (minimumValue == null) ? (double) Integer.MIN_VALUE : minimumValue.doubleValue();
       }
       else
       {
         return (minimumValue == null) ? -1.0*Double.MAX_VALUE : minimumValue.doubleValue();
         // NOTE: Double.MIN_VALUE returns the smallest positive value - oooops.
       }
    }
 
 /**
 * Sets which type of number this text field can accept.
 * @see #INTEGER
 * @see #FLOAT
 * @param newValueType The type of number to accept.
 */
    public void setValueType(int newValueType)
    {
       if ((newValueType != INTEGER) && (newValueType != FLOAT))
       {
          valueType = INTEGER;
       }
       else
       {
          valueType = newValueType;
       }
    }
 
 /**
 * Returns which type of number this text field accepts.  The default is
 * integer.
 * @see #INTEGER
 * @see #FLOAT
 * @return The type of number to accept.
 */
    public int getValueType()
    {
       return valueType;
    }
 
 /**
 * Returns the integer numeric value of the string in the text field.  The type
 * can be either integer of float.
 * @return The current value in the text field.
 */
    public int getIntValue()
    {
       int value = 0;
 
       try
       {
          value = Integer.parseInt(getText());
       }
       catch (NumberFormatException e)
       {
          try
          {
             Double dValue = Double.valueOf(getText());
             value = dValue.intValue();
          }
          catch (NumberFormatException ignored) {}
       }
 
       return value;
    }
 
 /**
 * Sets the text field to integer value specified.
 * @param aValue An integer value to display in the text field.
 */
    public void setIntValue(int aValue)
    {
       setText(Integer.toString(aValue));
    }
 
 /**
 * Returns the real number numeric value of the string in the text field.  The type
 * can be either integer of float.
 * @return The current value in the text field.
 */
    public double getDoubleValue()
    {
       Double value = new Double(0);
 
       try
       {
          value = Double.valueOf(getText());
       }
       catch (NumberFormatException ignored) {}
 
       return value.doubleValue();
    }
 
 /**
 * Sets the text field to the double value specified.  If the text field type is
 * FLOAT then the the number is display as a real number.  If the text field
 * type is INTEGER then the number is converted to a whole number for displaying.
 * @param aValue A double value to display in the text field.
 */
    public void setDoubleValue(double aValue)
    {
        Double temp = new Double(aValue);
 
        if (valueType == FLOAT)
        {
           setText(temp.toString());
        }
        else
        {
           setText(Integer.toString(temp.intValue()));
        }
    }
 
 /*******************************
 * PROTECTED METHODS
 *******************************/
 
    protected boolean isValidCharacter(char aChar)
    {
       if (((aChar >= ' ') && (aChar <= '/')) || ((aChar >= ':') && (aChar <= '~')))
       {
          if (aChar == '.')
          {
              if ( valueType == FLOAT )
              {
                  return true;
              }
              else
              {
                  return false;
              }
          }
          else if (aChar == '-')
          {
              if ( getMinimumValue() < 0 )
              {
                  return true;
              }
              else
              {
                  return false;
              }
          }
          else if (aChar == '+')
          {
              if ( getMaximumValue() >= 0 )
              {
                  return true;
              }
              else
              {
                  return false;
              }
          }
          return false;
       }
       return true;
    }
 
    protected boolean isValidString(String aString)
    {
       int iValue = 0;
       double dValue = 0.0;
 
       String tempString = new String(scanForSignChar(aString));
 
       if ( valueType == INTEGER )
       {
           try
           {
              iValue = Integer.parseInt(tempString);
           }
           catch (NumberFormatException e1)
           {
              if ((tempString.compareTo("-") == 0) && (getMinimumValue() < 0.0))
              {
                 iValue = 0;
              }
              else
              {
                 return false;
              }
           }
           if ((((double)iValue) < getMinimumValue()) || (((double)iValue) > getMaximumValue()))
           {
              return false;
           }
       }
       else
       {
           // Double.valueOf requires a zero before the decimal point
           if ( tempString.startsWith( "." ) )
           {
               tempString = "0" + tempString;
           }
           try
           {
              dValue = Double.valueOf(tempString).doubleValue();
           }
           catch (NumberFormatException e2)
           {
              if ((tempString.compareTo("-") == 0) && (getMinimumValue() < 0.0))
              {
                 dValue = 0.0;
              }
              else
              {
                 return false;
              }
           }
 
           if ((dValue < getMinimumValue()) || (dValue > getMaximumValue()))
           {
              return false;
           }
       }
 
       return true;
    }
 
    protected void postProcessing()
    {
       if (sign)
       {
          setText(scanForSignChar(getText()));
          setCaretPosition(newCaretPosition);
       }
       sign = false;
    }
 
 
 /*******************************
 * PRIVATE METHODS
 *******************************/
 
    private String scanForSignChar(String aString)
    {
       String newString = "";
       boolean positive = false;
       boolean negative = false;
       int oldCaretPosition = getCaretPosition();
       int charactersAdded = 0;
 
       newCaretPosition = 0;
 
       if (aString.length() <= 0)
       {
          return aString;
       }
 
       for (int i = 0; i < aString.length(); ++i)
       {
          switch (aString.charAt(i))
          {
             case '+': positive = true;
                       break;
             case '-': negative = true;
                       break;
             default:  newString += aString.charAt(i);
                       charactersAdded++;
                       break;
          }
 
          if ((i + 1) == oldCaretPosition)
          {
             newCaretPosition = charactersAdded;
          }
       }
 
       if ((!(positive)) && (negative))
       {
          newString = "-" + newString;
          newCaretPosition++;
       }
 
       if (positive || negative)
       {
          sign = true;
       }
 
       return newString;
    }
 }
 

1		/*
2		Wotonomy: OpenStep design patterns for pure Java applications.
3		Copyright (C) 2000 Blacksmith, Inc
4
5		This library is free software; you can redistribute it and/or
6		modify it under the terms of the GNU Lesser General Public
7		License as published by the Free Software Foundation; either
8		version 2.1 of the License, or (at your option) any later version.
9
10		This library is distributed in the hope that it will be useful,
11		but WITHOUT ANY WARRANTY; without even the implied warranty of
12		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13		Lesser General Public License for more details.
14
15		You should have received a copy of the GNU Lesser General Public
16		License along with this library; if not, see http://www.gnu.org
17		*/
18
19		package net.wotonomy.ui.swing.components;
20
21		/**
22		* NumericTextField is a "smart" text field that restricts the user's input. The
23		* input is restructed to numeric only wich can be of two types: integer and real
24		* numbers. A range can also be placed on the text field. The default type is
25		* integer, with the being (Integer.MIN_VALUE, Integer.MAX_VALUE).
26		*
27		* @author rob@straylight.princeton.com
28		* @author $Author: cgruber $
29		* @version $Revision: 893 $
30		*/
31		public class NumericTextField extends SmartTextField
32		{
33
34		/*******************************
35		* CONSTANTS
36		*******************************/
37
38		/**
39		* Restrict the text input to integers (whole numbers) only.
40		*/
41		public final static int INTEGER = 0;
42
43		/**
44		* Restrict the text input to floating-point numbers only.
45		*/
46		public final static int FLOAT = 1;
47
48	0	private Number maximumValue = null;
49	0	private Number minimumValue = null;
50
51	0	private boolean sign = false;
52	0	private int newCaretPosition = 0;
53	0	private int valueType = INTEGER;
54
55
56		/*******************************
57		* PUBLIC METHODS
58		*******************************/
59
60		/**
61		* Default constructor.
62		*/
63		public NumericTextField()
64		{
65	0	this("", 0);
66	0	}
67
68		/**
69		* Constructor.
70		* @param text The initial string the text field is set to.
71		*/
72		public NumericTextField(String text)
73		{
74	0	this(text, 0);
75	0	}
76
77		/**
78		* Constructor.
79		* @param columns Width of the text field (in characters).
80		*/
81		public NumericTextField(int columns)
82		{
83	0	this("", columns);
84	0	}
85
86		/**
87		* Constructor.
88		* @param text The initial string the text field is set to.
89		* @param columns Width of the text field (in characters).
90		*/
91		public NumericTextField(String text, int columns)
92		{
93	0	super(text, columns);
94	0	}
95
96		/**
97		* Sets the upper limit of the range of numbers to accept.
98		* @param newMaximumValue The maximum number accepted by the text field.
99		*/
100		public void setMaximumValue(double newMaximumValue)
101		{
102	0	if (newMaximumValue >= 0)
103		{
104	0	maximumValue = new Double( newMaximumValue );
105	0	}
106		else
107		{
108	0	maximumValue = null;
109		}
110	0	}
111
112		/**
113		* Returns the upper limit of the range of numbers to accept.
114		* @return The maximum number accepted by this text field.
115		*/
116		public double getMaximumValue()
117		{
118	0	if ( valueType == INTEGER )
119		{
120	0	return (maximumValue == null) ? (double) Integer.MAX_VALUE : maximumValue.doubleValue();
121		}
122		else
123		{
124	0	return (maximumValue == null) ? Double.MAX_VALUE : maximumValue.doubleValue();
125		}
126		}
127
128		/**
129		* Sets the lower limit of the range of numbers to accept.
130		* @param newMinimumValue The minimum number accepted by the text field.
131		*/
132		public void setMinimumValue(double newMinimumValue)
133		{
134	0	if (newMinimumValue <= 0)
135		{
136	0	minimumValue = new Double( newMinimumValue );
137	0	}
138		else
139		{
140	0	minimumValue = null;
141		}
142	0	}
143
144		/**
145		* Returns the lower limit of the range of numbers to accept.
146		* @return The minimum number accepted by this text field.
147		*/
148		public double getMinimumValue()
149		{
150	0	if ( valueType == INTEGER )
151		{
152	0	return (minimumValue == null) ? (double) Integer.MIN_VALUE : minimumValue.doubleValue();
153		}
154		else
155		{
156	0	return (minimumValue == null) ? -1.0*Double.MAX_VALUE : minimumValue.doubleValue();
157		// NOTE: Double.MIN_VALUE returns the smallest positive value - oooops.
158		}
159		}
160
161		/**
162		* Sets which type of number this text field can accept.
163		* @see #INTEGER
164		* @see #FLOAT
165		* @param newValueType The type of number to accept.
166		*/
167		public void setValueType(int newValueType)
168		{
169	0	if ((newValueType != INTEGER) && (newValueType != FLOAT))
170		{
171	0	valueType = INTEGER;
172	0	}
173		else
174		{
175	0	valueType = newValueType;
176		}
177	0	}
178
179		/**
180		* Returns which type of number this text field accepts. The default is
181		* integer.
182		* @see #INTEGER
183		* @see #FLOAT
184		* @return The type of number to accept.
185		*/
186		public int getValueType()
187		{
188	0	return valueType;
189		}
190
191		/**
192		* Returns the integer numeric value of the string in the text field. The type
193		* can be either integer of float.
194		* @return The current value in the text field.
195		*/
196		public int getIntValue()
197		{
198	0	int value = 0;
199
200		try
201		{
202	0	value = Integer.parseInt(getText());
203		}
204	0	catch (NumberFormatException e)
205		{
206		try
207		{
208	0	Double dValue = Double.valueOf(getText());
209	0	value = dValue.intValue();
210		}
211	0	catch (NumberFormatException ignored) {}
212	0	}
213
214	0	return value;
215		}
216
217		/**
218		* Sets the text field to integer value specified.
219		* @param aValue An integer value to display in the text field.
220		*/
221		public void setIntValue(int aValue)
222		{
223	0	setText(Integer.toString(aValue));
224	0	}
225
226		/**
227		* Returns the real number numeric value of the string in the text field. The type
228		* can be either integer of float.
229		* @return The current value in the text field.
230		*/
231		public double getDoubleValue()
232		{
233	0	Double value = new Double(0);
234
235		try
236		{
237	0	value = Double.valueOf(getText());
238		}
239	0	catch (NumberFormatException ignored) {}
240
241	0	return value.doubleValue();
242		}
243
244		/**
245		* Sets the text field to the double value specified. If the text field type is
246		* FLOAT then the the number is display as a real number. If the text field
247		* type is INTEGER then the number is converted to a whole number for displaying.
248		* @param aValue A double value to display in the text field.
249		*/
250		public void setDoubleValue(double aValue)
251		{
252	0	Double temp = new Double(aValue);
253
254	0	if (valueType == FLOAT)
255		{
256	0	setText(temp.toString());
257	0	}
258		else
259		{
260	0	setText(Integer.toString(temp.intValue()));
261		}
262	0	}
263
264		/*******************************
265		* PROTECTED METHODS
266		*******************************/
267
268		protected boolean isValidCharacter(char aChar)
269		{
270	0	if (((aChar >= ' ') && (aChar <= '/')) \|\| ((aChar >= ':') && (aChar <= '~')))
271		{
272	0	if (aChar == '.')
273		{
274	0	if ( valueType == FLOAT )
275		{
276	0	return true;
277		}
278		else
279		{
280	0	return false;
281		}
282		}
283	0	else if (aChar == '-')
284		{
285	0	if ( getMinimumValue() < 0 )
286		{
287	0	return true;
288		}
289		else
290		{
291	0	return false;
292		}
293		}
294	0	else if (aChar == '+')
295		{
296	0	if ( getMaximumValue() >= 0 )
297		{
298	0	return true;
299		}
300		else
301		{
302	0	return false;
303		}
304		}
305	0	return false;
306		}
307	0	return true;
308		}
309
310		protected boolean isValidString(String aString)
311		{
312	0	int iValue = 0;
313	0	double dValue = 0.0;
314
315	0	String tempString = new String(scanForSignChar(aString));
316
317	0	if ( valueType == INTEGER )
318		{
319		try
320		{
321	0	iValue = Integer.parseInt(tempString);
322		}
323	0	catch (NumberFormatException e1)
324		{
325	0	if ((tempString.compareTo("-") == 0) && (getMinimumValue() < 0.0))
326		{
327	0	iValue = 0;
328	0	}
329		else
330		{
331	0	return false;
332		}
333	0	}
334	0	if ((((double)iValue) < getMinimumValue()) \|\| (((double)iValue) > getMaximumValue()))
335		{
336	0	return false;
337		}
338		}
339		else
340		{
341		// Double.valueOf requires a zero before the decimal point
342	0	if ( tempString.startsWith( "." ) )
343		{
344	0	tempString = "0" + tempString;
345		}
346		try
347		{
348	0	dValue = Double.valueOf(tempString).doubleValue();
349		}
350	0	catch (NumberFormatException e2)
351		{
352	0	if ((tempString.compareTo("-") == 0) && (getMinimumValue() < 0.0))
353		{
354	0	dValue = 0.0;
355	0	}
356		else
357		{
358	0	return false;
359		}
360	0	}
361
362	0	if ((dValue < getMinimumValue()) \|\| (dValue > getMaximumValue()))
363		{
364	0	return false;
365		}
366		}
367
368	0	return true;
369		}
370
371		protected void postProcessing()
372		{
373	0	if (sign)
374		{
375	0	setText(scanForSignChar(getText()));
376	0	setCaretPosition(newCaretPosition);
377		}
378	0	sign = false;
379	0	}
380
381
382		/*******************************
383		* PRIVATE METHODS
384		*******************************/
385
386		private String scanForSignChar(String aString)
387		{
388	0	String newString = "";
389	0	boolean positive = false;
390	0	boolean negative = false;
391	0	int oldCaretPosition = getCaretPosition();
392	0	int charactersAdded = 0;
393
394	0	newCaretPosition = 0;
395
396	0	if (aString.length() <= 0)
397		{
398	0	return aString;
399		}
400
401	0	for (int i = 0; i < aString.length(); ++i)
402		{
403	0	switch (aString.charAt(i))
404		{
405	0	case '+': positive = true;
406	0	break;
407	0	case '-': negative = true;
408	0	break;
409	0	default: newString += aString.charAt(i);
410	0	charactersAdded++;
411		break;
412		}
413
414	0	if ((i + 1) == oldCaretPosition)
415		{
416	0	newCaretPosition = charactersAdded;
417		}
418		}
419
420	0	if ((!(positive)) && (negative))
421		{
422	0	newString = "-" + newString;
423	0	newCaretPosition++;
424		}
425
426	0	if (positive \|\| negative)
427		{
428	0	sign = true;
429		}
430
431	0	return newString;
432		}
433		}
434