Coverage Report - net.wotonomy.ui.swing.components.AlphaTextField
 
Classes in this File Line Coverage Branch Coverage Complexity
AlphaTextField
0% 
0% 
3
 
 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  
 * AlphaTextField is a "smart" text field that restricts the user's input.  The
 23  
 * input can be restricted to alphabetic, alphanumeric, or all characters.  The
 24  
 * maximum number of characters can also be limited.
 25  
 * The defaults for this component is alphabetic only string of unlimited length.
 26  
 *
 27  
 * @author rob@straylight.princeton.com
 28  
 * @author $Author: cgruber $
 29  
 * @version $Revision: 893 $
 30  
 */
 31  
 public class AlphaTextField extends SmartTextField
 32  
 {
 33  
 
 34  
 /*******************************
 35  
 * CONSTANTS
 36  
 *******************************/
 37  
 
 38  
 /**
 39  
 * Sets the input to alphabetic characters only.  The characters "a-z" and "A-Z"
 40  
 * are the only valid characters.  All other characters will be ignored.
 41  
 * @see #getAlphaType()
 42  
 */
 43  
    public static final int ALPHABETIC = 0;
 44  
 
 45  
 /**
 46  
 * Sets the input to alphanumeric characters only.  The characters "a-z", "A-Z"
 47  
 * and "0-9" are the only valid characters.  All other characters will be ignored.
 48  
 * @see #getAlphaType()
 49  
 */
 50  
    public static final int ALPHANUMERIC = 1;
 51  
 
 52  
 /**
 53  
 * Sets the input to alphanumeric characters and a few special characters only.
 54  
 * The valid characters are "a-z", "A-Z", "0-9", space, "-", "_", "\", and ":".
 55  
 * This is helpful for file names (with paths) as input strings.
 56  
 * All other characters will be ignored.
 57  
 * @see #getAlphaType()
 58  
 */
 59  
    public static final int ALPHANUMERIC_PLUS = 2;
 60  
 
 61  
 /**
 62  
 * Sets the input to all characters without restriction.
 63  
 * @see #getAlphaType()
 64  
 */
 65  
    public static final int ALL = 3;
 66  
 
 67  
 
 68  
 /*******************************
 69  
 * DATA MEMBERS
 70  
 *******************************/
 71  
 
 72  
    // The level of input restrictions, defaults to ALPHABETIC
 73  
    private int alphaType;
 74  
 
 75  
    // The maximum length of the input string, defaults to 0, no maximum
 76  
    private int stringLength;
 77  
 
 78  
 
 79  
 /*******************************
 80  
 * PUBLIC METHODS
 81  
 *******************************/
 82  
 
 83  
 /**
 84  
 * The default constructor of this class.  The default string of this text
 85  
 * field is set to the empty string ("").  The maximum length is set to 0,
 86  
 * which specifies no limit.
 87  
 */
 88  
    public AlphaTextField()
 89  
    {
 90  0
       this("", 0);
 91  0
    }
 92  
 
 93  
 /**
 94  
 * Constructor of this class with the initial text of the text field specified.
 95  
 * The maximum length is set to 0, which specifies no limit.
 96  
 * @param text Initial text of the text field.
 97  
 */
 98  
    public AlphaTextField(String text)
 99  
    {
 100  0
       this(text, 0);
 101  0
    }
 102  
 
 103  
 /**
 104  
 * Constructor of this class with width (in columns) of the text field specified.
 105  
 * The initial text is set to the empty string (""). The maximum length is set
 106  
 * to 0, which specifies no limit.
 107  
 * @param columns The width of the text field in characters.
 108  
 */
 109  
    public AlphaTextField(int columns)
 110  
    {
 111  0
       this("", columns);
 112  0
    }
 113  
 
 114  
 /**
 115  
 * Constructor of this class with width (in columns) and initial text of the
 116  
 * text field specified.  The maximum length is set to 0, which specifies no limit.
 117  
 * @param text Initial text of the text field.
 118  
 * @param columns The width of the text field in characters.
 119  
 */
 120  
    public AlphaTextField(String text, int columns)
 121  
    {
 122  0
       super(text, columns);
 123  0
    }
 124  
 
 125  
 /**
 126  
 * Constructor that allows the user to set the Alpha type of the text field
 127  
 * and the maximum string length.
 128  
 * @param anAlphaType The character restriction type.
 129  
 * @param aLength The maximum number of characters allowed in the string.
 130  
 */
 131  
    public AlphaTextField(int anAlphaType, int aLength)
 132  
    {
 133  0
        super( "", 0 );
 134  0
        setAlphaType( anAlphaType );
 135  0
        setStringLength( aLength );
 136  0
    }
 137  
 
 138  
 /**
 139  
 * Gets the current restriction type of this text field.
 140  
 * @see #ALPHABETIC
 141  
 * @see #ALPHANUMERIC
 142  
 * @see #ALPHANUMERIC_PLUS
 143  
 * @see #ALL
 144  
 * @return The current restriction type as defined by the constansts of this class.
 145  
 */
 146  
    public int getAlphaType()
 147  
    {
 148  0
       return alphaType;
 149  
    }
 150  
 
 151  
 /**
 152  
 * Sets the restriction type of this text field.
 153  
 * @see #ALPHABETIC
 154  
 * @see #ALPHANUMERIC
 155  
 * @see #ALPHANUMERIC_PLUS
 156  
 * @see #ALL
 157  
 * @param newAlphaType The restriction of this text field.
 158  
 */
 159  
    public void setAlphaType(int newAlphaType)
 160  
    {
 161  0
       switch (newAlphaType)
 162  
       {
 163  
          case ALPHABETIC:
 164  
          case ALPHANUMERIC:
 165  
          case ALPHANUMERIC_PLUS:
 166  
          case ALL:
 167  
          {
 168  0
             alphaType = newAlphaType;
 169  0
             break;
 170  
          }
 171  
          default:
 172  
          {
 173  0
             alphaType = ALPHABETIC;
 174  
             break;
 175  
          }
 176  
       }
 177  0
    }
 178  
 
 179  
 /**
 180  
 * Sets the maximum string length of this text field.  If the length is set to
 181  
 * zero, then there is no limit.  The default string length is zero.  Negative
 182  
 * sizes will set the length to zero.
 183  
 * @param newStringLength The maximum length of the string that the user can input.
 184  
 */
 185  
    public void setStringLength(int newStringLength)
 186  
    {
 187  0
       if (newStringLength < 0)
 188  
       {
 189  0
          stringLength = 0;
 190  0
       }
 191  
       else
 192  
       {
 193  0
          stringLength = newStringLength;
 194  
       }
 195  0
    }
 196  
 
 197  
 /**
 198  
 * Gets the current length of the maximum string size the user can enter.
 199  
 * @return The maximum length the string of the text field can be.
 200  
 */
 201  
    public int getStringLength()
 202  
    {
 203  0
       return stringLength;
 204  
    }
 205  
 
 206  
 
 207  
 /*******************************
 208  
 * PROTECTED METHODS
 209  
 *******************************/
 210  
 
 211  
    protected boolean isValidCharacter(char aChar)
 212  
    {
 213  
       // if its a non-printable character, then its ok
 214  0
       if ((aChar < ' ') || (aChar > '~'))
 215  
       {
 216  0
          return true;
 217  
       }
 218  
 
 219  
       // can only be a printable character now, check it for validation
 220  0
       return isValidCharacterType(aChar);
 221  
    }
 222  
 
 223  
    protected boolean isValidString(String aString)
 224  
    {
 225  0
       if (aString.length() > stringLength)
 226  
       {
 227  0
          return false;
 228  
       }
 229  
 
 230  0
       for (int i = 0; i < aString.length(); ++i)
 231  
       {
 232  0
          if (!(isValidCharacterType(aString.charAt(i))))
 233  
          {
 234  0
             return false;
 235  
          }
 236  
       }
 237  
 
 238  0
       return true;
 239  
    }
 240  
 
 241  
    protected void postProcessing()
 242  
    {
 243  
       // No need to do anything.
 244  0
    }
 245  
 
 246  
 
 247  
 /*******************************
 248  
 * PROTECTED METHODS
 249  
 *******************************/
 250  
 
 251  
    private boolean isValidCharacterType(char aChar)
 252  
    {
 253  0
       switch (alphaType)
 254  
       {
 255  
          case ALPHABETIC:
 256  
          {
 257  0
             if (!(isValidAlphabeticCharacter(aChar)))
 258  
             {
 259  0
                return false;
 260  
             }
 261  0
             break;
 262  
          }
 263  
          case ALPHANUMERIC:
 264  
          {
 265  0
             if (!(isValidAlphanumericCharacter(aChar)))
 266  
             {
 267  0
                return false;
 268  
             }
 269  0
             break;
 270  
          }
 271  
          case ALPHANUMERIC_PLUS:
 272  
          {
 273  0
             if (!(isValidAlphanumericPlusCharacter(aChar)))
 274  
             {
 275  0
                return false;
 276  
             }
 277  0
             break;
 278  
          }
 279  
          case ALL:
 280  
          {
 281  0
             if (!(isValidAllCharacter(aChar)))
 282  
             {
 283  0
                return false;
 284  
             }
 285  0
             break;
 286  
          }
 287  
          default:
 288  
          {
 289  0
             return false;
 290  
          }
 291  
       }
 292  
 
 293  0
       return true;
 294  
    }
 295  
 
 296  
    private boolean isValidAlphabeticCharacter(char aChar)
 297  
    {
 298  0
       if (((aChar < 'A') || (aChar > 'Z')) && ((aChar < 'a') || (aChar > 'z')))
 299  
       {
 300  0
          return false;
 301  
       }
 302  0
       return true;
 303  
    }
 304  
 
 305  
    private boolean isValidAlphanumericCharacter(char aChar)
 306  
    {
 307  0
       if (((aChar < 'A') || (aChar > 'Z')) && ((aChar < 'a') || (aChar > 'z')) && ((aChar < '0') || (aChar > '9')))
 308  
       {
 309  0
          return false;
 310  
       }
 311  0
       return true;
 312  
    }
 313  
 
 314  
    private boolean isValidAlphanumericPlusCharacter(char aChar)
 315  
    {
 316  0
       if (((aChar < 'A') || (aChar > 'Z')) && ((aChar < 'a') || (aChar > 'z')) && ((aChar < '0') || (aChar > '9')))
 317  
       {
 318  0
          if ((aChar != ' ') && (aChar != '_') && (aChar != '-') && (aChar != ':') && (aChar != '\\'))
 319  
          {
 320  0
             return false;
 321  
          }
 322  
       }
 323  0
       return true;
 324  
    }
 325  
 
 326  
    private boolean isValidAllCharacter(char aChar)
 327  
    {
 328  0
       if ((aChar < ' ') || (aChar > '~'))
 329  
       {
 330  0
          return false;
 331  
       }
 332  0
       return true;
 333  
    }
 334  
 
 335  
 }