home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgLangD.iso / VCAFE.3.0A / Main.bin / MaskedTextField.java < prev    next >
Text File  |  1998-12-11  |  10KB  |  253 lines
  1. package com.symantec.itools.awt;
  2.  
  3. import java.awt.event.KeyEvent;
  4. import java.awt.event.KeyAdapter;
  5. import java.awt.event.FocusEvent;
  6. import java.awt.event.FocusAdapter;
  7. import java.awt.datatransfer.*;
  8. import com.symantec.itools.swing.MaskEngine;
  9.  
  10. public class MaskedTextField extends java.awt.TextField {
  11.  
  12.     /* These constants are used to specify the data type information needed
  13.         to specialize input time behavior based on data type.
  14.         For now, the only such difference is between text and numeric:
  15.         In numeric fields, an empty field is initialzed to zero, and input of
  16.         a decimal point when the mask contains one and the cartet is to its left
  17.         causes the caret to move to the right of the decimal point position.
  18.     */
  19.     public static final int texttype = MaskEngine.texttype;
  20.     public static final int numbtype = MaskEngine.numbtype;
  21.     public static final int datetype = MaskEngine.datetype;
  22.     public static final int timetype = MaskEngine.timetype;
  23.  
  24.     // ctors
  25.     public MaskedTextField (                   ) { this(""         , 0              ); }
  26.     public MaskedTextField (int numberOfColumns) { this(""         , numberOfColumns); }
  27.     public MaskedTextField (String initialText ) { this(initialText, 256            ); }
  28.  
  29.     // All other constructors call this one
  30.     public MaskedTextField(String initialText, int numberOfColumns)    {
  31.         super(initialText, numberOfColumns);
  32.     }
  33.     
  34.     //over-ride 
  35.     public synchronized void setText ( String t ) {
  36.         if ( t != null && t.length() > 0 ) {
  37.             super.setText ( getMatchedText ( t ) ) ;
  38.         }
  39.         else {
  40.             super.setText( t );
  41.         }
  42.     }
  43.     
  44.  
  45.     /**
  46.         Initialize the field
  47.     */
  48.     public synchronized void setMaskedText(String t) {
  49.         StringBuffer newData = new StringBuffer();
  50.         _firstInputPos = _maskEngine.initDisplay(t, newData);
  51.         super.setText(newData.toString());
  52.         if (_haveFocus && isEditable())
  53.             select(_firstInputPos, _firstInputPos + 1);
  54.         _dataComplete = false;
  55.     }
  56.  
  57.     // Returns current text with mask characters removed
  58.     public synchronized String getUnmaskedText() {
  59.         StringBuffer newData = new StringBuffer();
  60.         _dataComplete = _maskEngine.stripMask(getText(), newData);
  61.         return newData.toString();
  62.     }
  63.  
  64.     public boolean isDataComplete() {
  65.         if (!_dataComplete) {
  66.             if (!_activity)
  67.                 return true;
  68.             _dataComplete = _maskEngine.stripMask(getText(), new StringBuffer());
  69.         }
  70.         return _dataComplete;
  71.     }
  72.  
  73.     protected String  getMatchedText ( String t ) {
  74.     
  75.         return  _maskEngine.getMatchedText ( t );
  76.     
  77.     }
  78.     
  79.     /**
  80.     * This is a standard AWT method which gets called when
  81.     * this component is added to a container. Typically, it is used to
  82.     * create this component's peer.
  83.     * It has been overridden to add listener(s).
  84.     *
  85.     * @see #removeNotify
  86.     */
  87.     public synchronized void addNotify() {
  88.         if (_focusListener == null) {
  89.             _focusListener = new FocusAdapter() {
  90.                 public void focusGained(FocusEvent e) { gotFocus (e); }
  91.                 public void focusLost  (FocusEvent e) { lostFocus(e); }
  92.             };
  93.             addFocusListener(_focusListener);
  94.             if (isEditable()) {
  95.                 _keyListener = new KeyAdapter() {
  96.                     public void keyPressed (KeyEvent e) { keyPress  (e); }
  97.                     public void keyTyped   (KeyEvent e) { keyType   (e); }
  98.                     public void keyReleased(KeyEvent e) { keyRelease(e); }
  99.                 };
  100.                 addKeyListener(_keyListener);
  101.             }
  102.         }
  103.         super.addNotify();
  104.     }
  105.  
  106.    /**
  107.     * This method gets called when this component is removed from a
  108.     * container. Typically, it is used to destroy the peers of this
  109.     * component and all its subcomponents.
  110.     * It has been overridden here to remove listener(s).
  111.     *
  112.     * @see #addNotify
  113.     */
  114.     public synchronized void removeNotify() {
  115.         if (_focusListener != null) {
  116.             removeFocusListener(_focusListener);
  117.             _focusListener = null;
  118.             if (_keyListener != null)
  119.                   removeKeyListener(_keyListener);
  120.             _keyListener = null;
  121.         }
  122.         super.removeNotify();
  123.     }
  124.  
  125.     protected void gotFocus(FocusEvent e) {
  126.         _haveFocus = true;
  127.         _activity = false;
  128.         if (getText().length() == 0) {
  129.             setMaskedText("");  // show the mask literals if field is empty
  130.         } else {
  131.             if (isEditable() && _lastContents.compareTo(getText()) != 0)
  132.                 select(_firstInputPos, _firstInputPos + 1);
  133.             _dataComplete = false;
  134.         }
  135.     }
  136.  
  137.     protected void lostFocus(FocusEvent e) {
  138.         _haveFocus = false;
  139.         _lastContents = getText();
  140.     }
  141.  
  142.     protected void keyPress(KeyEvent e) {
  143.         _activity = true;
  144.         if (_maskEngine.isHandledKey(e) && isEditable()) {
  145.             e.consume();
  146.             if (_keyPressed) { // key must be auto-repeating
  147.                 if (Character.isISOControl(e.getKeyChar()))
  148.                     processKey(e);
  149.             } else
  150.                 _keyPressed = true;
  151.         }
  152.     }
  153.  
  154.     protected void keyType(KeyEvent e) {
  155.         _activity = true;
  156.         if (_maskEngine.isHandledKey(e) && isEditable())
  157.             processKey(e);
  158.     }
  159.  
  160.     protected void keyRelease(KeyEvent e) {
  161.         _keyPressed = false;
  162.         _activity = true;
  163.         if (_maskEngine.isHandledKey(e) && isEditable()) {
  164.             if (Character.isISOControl(e.getKeyChar()))
  165.                 processKey(e);
  166.         }
  167.     }
  168.  
  169.     protected void processKey(KeyEvent e) {
  170.         e.consume();
  171.         StringBuffer newData = new StringBuffer("");
  172.         int pos = getCaretPosition();
  173.         String data = getText();
  174.         int newpos = _maskEngine.processKey(e, pos, data, newData,
  175.                                             getSelectionStart(), getSelectionEnd());
  176.         if (newpos == -2)  // quit if filter mismatch
  177.             return;
  178.         super.setText(newData.toString());
  179.         if (newpos >= 0) {              // if good new caret position
  180.             select(newpos, newpos + 1);  // select this position
  181.         } else if (newpos == -1) {
  182.             java.awt.Toolkit.getDefaultToolkit().beep();
  183.             select(pos, pos);
  184.         } else {  // cursor just moved out of range
  185.             select(0,0);  // turn off selection
  186.             setCaretPosition(newpos + 1000);  // move one past last filter
  187.         }
  188.     }
  189.  
  190.     public synchronized void cut(Clipboard clipboard) {
  191.         if (!isEditable())
  192.             return;
  193.         _activity = true;
  194.         StringBuffer newData = new StringBuffer();
  195.         int selStart = getSelectionStart();
  196.         String clipboardData = _maskEngine.cut(getText(), selStart,
  197.                                             getSelectionEnd(),
  198.                                             newData);
  199.         StringSelection ss = new StringSelection(clipboardData);
  200.         clipboard.setContents(ss, ss);
  201.         super.setText(newData.toString());
  202.         setCaretPosition(selStart);
  203.     }
  204.  
  205.     public synchronized boolean paste(Clipboard clipboard) {
  206.         if (!isEditable())
  207.             return true;
  208.         _activity = true;
  209.         StringBuffer newData = new StringBuffer();
  210.         String data = "";
  211.         try {
  212.             data = (String)clipboard.getContents(this).getTransferData(DataFlavor.stringFlavor);
  213.         } catch (Exception e) { return false; }
  214.         int newpos = _maskEngine.paste(getText(), data, getCaretPosition(), newData,
  215.                             getSelectionStart(), getSelectionEnd());
  216.         if (newpos < 0)   // beep if paste failed
  217.             getToolkit().beep();
  218.         if (newpos == -2) // quit if filter mismatch
  219.             return false;
  220.         super.setText(newData.toString());
  221.         if (newpos >= 0) {              // if good new caret position
  222.             select(newpos, newpos + 1);  // select this position
  223.         } else {
  224.             select(0, 0);  // turn off selection
  225.         if (newpos != -1)  // cursor just moved out of range
  226.             setCaretPosition(newpos + 1000);  // move one past last filter
  227.         }
  228.         return true;
  229.     }
  230.  
  231.     // Property accessors
  232.     public void   setMask    (String mask) {
  233.         _maskEngine.setMask    (mask); 
  234.         setText ( getText() );
  235.     }
  236.     
  237.     public String getMask    (           ) { return _maskEngine.getMask    (    ); }
  238.     public void   setDatatype(int    type) {        _maskEngine.setDatatype(type); }
  239.     public int    getDatatype(           ) { return _maskEngine.getDatatype(    ); }
  240.  
  241.     // Variables
  242.     private FocusAdapter  _focusListener = null;
  243.     private MaskEngine    _maskEngine    = new MaskEngine();
  244.     private KeyAdapter    _keyListener   = null;
  245.     private boolean       _dataComplete  = false;   // true iff no mandatory filters are empty
  246.     private boolean       _haveFocus     = false;   // true if this component has input focus
  247.     private boolean       _activity      = false;
  248.     private boolean       _keyPressed    = false;
  249.     private String        _lastContents  = "";      // contents on last loss of focus
  250.     private int           _firstInputPos = 0;       // position of first filter
  251. }
  252.  
  253.