numbertextfield.java

一个用java写的地震分析软件(无源码)-used to write a seismic analysis software (without source)

        else {
            limitsErrorActionStates.setErrorActionStates(log, audio, reset, popup);
        }
    }

/**
 * Input into field is bounds checked.
*/
    public RangeLimits getLimits() {
        return (limits == null) ? null : (RangeLimits) limits.clone();
    }

    public void setLimits(Number minLimit, Number maxLimit) {
        if (limits == null) limits = new RangeLimits(minLimit, maxLimit);
        else limits.setLimits(minLimit, maxLimit);
        if (limits.isLimited()) this.setToolTipText(limits.toString());

        if (limitsErrorActionStates == null) limitsErrorActionStates = new ConstraintErrorActionStates();
    }

    public void setInputVerifier(InputVerifier inputVerifier) {
        this.inputVerifier = inputVerifier;
    }

    public InputVerifier getInputVerifier() {
        return inputVerifier;
    }

    public boolean verifyValid() {
        InputVerifier iv = getInputVerifier();
        if (iv == null) {
            validityValue = true;
            notifyValueChanged(stringToNumber(getText()), validityValue);
            return validityValue;
        }
        else return iv.shouldYieldFocus(this);
    }

    public boolean accepts(Number value) {
        return checkInputConstraints(value);
    }

    private void addValidityListeners() {
        addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent evt) {
                if (verifyValid() && transferFocusOnAction) transferFocus();
            }
        });

        getDocument().addDocumentListener( new DocumentListener() {
            public void changedUpdate(DocumentEvent evt) {
                textChanged = true;
            }
            public void insertUpdate(DocumentEvent evt) {
                textChanged = true;
            }
            public void removeUpdate(DocumentEvent evt) {
                textChanged = true;
            }
        });

        addFocusListener(new FocusListener()  {

            private boolean verifying = false;

            public void focusGained(FocusEvent evt) {
                ((JTextComponent) evt.getSource()).selectAll();
//              System.out.println("focusGained evt.toString: " + evt.paramString() + " " + evt.getSource().getClass().getName());
            }

            public void focusLost(FocusEvent evt) {
//              System.out.println("focusLost evt.toString: " + evt.paramString() + " " + evt.getSource().getClass().getName());
                if (evt.isTemporary()) return;
//              if (textChanged ) {
                if (textChanged || (! validityValue && informInvalidityOnFocusLost)) {
                    textChanged = false;
                    if (verifying)  return;
                    verifying = true;
                    verifyValid();
                    verifying = false;
                }
            }
        });

    }

    public boolean isTransferFocusOnAction() {
        return transferFocusOnAction;
    }

    public void setTransferFocusOnAction(boolean value) {
        transferFocusOnAction = value;
    }

    public boolean isNullAllowed() {
        return nullAllowed;
    }

    public void setNullAllowed(boolean value) {
        nullAllowed = value;
    }

    public boolean hasDefaultValue() {
        return (defaultValue == null) ? false : true;
    }

    public Number getDefaultValue() {
        return defaultValue;
    }

/** Sets the default value to reset to upon error.
* @throws IllegalArgumentException default value is outside of limit bounds.
*/
    public void setDefaultValue(Number defaultValue) {
        if (limits != null && limits.isLimited()) {
           if (limits.excludes(defaultValue))
                 throw new IllegalArgumentException("DefaultValue Outside limit bounds.");
        }
        this.defaultValue = defaultValue;
        setToolTipText(getToolTipText() + " Default: " + defaultValue);
    }

/** Checks inputs for limit constraint violations.
* If input is null, returns true if nulls are allowed or a default value is declared.
* Resets empty field to default if any, else returns false.
* Returns true if input is within limit bounds.
*/
    protected boolean checkInputConstraints() {
        return checkInputConstraints(stringToNumber(getText()));
    }

    protected boolean checkInputConstraints(Number value) {
        if (value == null) {
            if (nullAllowed) return true;
            else {
                if (hasDefaultValue()) {
                    setValue(defaultValue);
                    return true;
                }
                else return false;
            }
        }
        return (limits == null || limits.contains((Object) value)) ;
    }

    protected void notifyInputBoundsViolated(Object value) {
        if (limitsErrorActionStates == null) return;

        if (limitsErrorActionStates.isAudioOnError()) Toolkit.getDefaultToolkit().beep();
        if (limitsErrorActionStates.isLogOnError()) {
            System.err.println("NumberTextField input Error " + getActionCommand() + " " + limits.toString() + " ; " +
                                String.valueOf(value) + " is out of bounds.");
        }
        if (limitsErrorActionStates.isPopupOnError()) {
            Container container = getTopLevelAncestor();
            if (container != null && container.isShowing())
                InfoDialog.informUser(container, "ERROR", getActionCommand() + " " +
                                  limits.toString() + " ; " + String.valueOf(value) + " is out of bounds.");
        }
        if (limitsErrorActionStates.isResetOnError()) resetValue();
    }

    public void resetValue() {
        if (hasDefaultValue()) setValue(defaultValue);
        else if (nullAllowed) setText("");
    }

    private void notifyValueChanged(Number newNumberValue, boolean newValidityValue) {
        setValidityBackground(newValidityValue);
        if ( ((newNumberValue != numberValue ) && (newNumberValue == null || ! newNumberValue.equals(numberValue))) ||
                (newValidityValue != validityValue) ) {
            Number oldNumberValue = numberValue;
            numberValue = newNumberValue;
            boolean oldValidityValue = validityValue;
            validityValue = newValidityValue;
            fireValueChanged("value", oldNumberValue, numberValue, newValidityValue);
        }
    }

    private void setValidityBackground(boolean validityValue) {
        if(validityValue) setBackground(Color.white);
        else setBackground(Color.pink);
    }

    public boolean isInformInvalidityOnFocusLost() {
        return informInvalidityOnFocusLost;
    }

    public void setInformInvalidityOnFocusLost(boolean value) {
        informInvalidityOnFocusLost = value;
    }

/*
    private void notifyValueChanged(Number newNumberValue) {
        if (  (newNumberValue != numberValue ) &&
              (newNumberValue == null || ! newNumberValue.equals(numberValue)) ) {
            Number oldNumberValue = numberValue;
            numberValue = newNumberValue;
            firePropertyChange("value", oldNumberValue, numberValue);
        }
    }

    private void notifyValidityChanged(boolean newValidityValue) {
        if (newValidityValue != validityValue) {
            validityValue = newValidityValue;
            if(validityValue) setBackground(Color.white);
            else setBackground(Color.pink);
            firePropertyChange("validity", ! oldValidityValue, validityValue);
        }
    }
*/
    class NumberTextFieldVerifier extends InputVerifier {
        public boolean shouldYieldFocus(JComponent comp) {
            NumberTextField ntf = (NumberTextField) comp;
            Number value = ntf.stringToNumber(ntf.getText());
            boolean valid = ntf.checkInputConstraints(value);
            ntf.notifyValueChanged(value, valid);
            if (! valid) ntf.notifyInputBoundsViolated(value);
            return valid;
        }

        public boolean verify(JComponent comp) {
            return ((NumberTextField) comp).checkInputConstraints();
        }
    }

    public synchronized void addValueChangedListener(ValueChangedListener listener) {
        listenerList.add(ValueChangedListener.class, listener);
    }

    public synchronized void removeValueChangedListener(ValueChangedListener listener) {
       listenerList.remove(ValueChangedListener.class, listener);
    }

    protected void fireValueChanged(ValueChangedEvent event) {
        Object[] listeners = listenerList.getListenerList();
        for (int idx = listeners.length-2; idx >= 0; idx -= 2) {
            if (listeners[idx] == ValueChangedListener.class) {
                ((ValueChangedListener) listeners[idx+1]).valueChanged(event);
            }
        }
    }

    protected void fireValueChanged(String name, Object oldValue, Object newValue, boolean newValidity) {
        Object[] listeners = listenerList.getListenerList();
        ValueChangedEvent event = null;
        for (int idx = listeners.length-2; idx >= 0; idx -= 2) {
            if (listeners[idx] == ValueChangedListener.class) {
                if (event == null) event = new ValueChangedEvent(this, name, oldValue, newValue, newValidity);
                ((ValueChangedListener) listeners[idx+1]).valueChanged(event);
            }
        }
    }

} // end of NumberTextField class