uiinput.java

RESIN 3.2 最新源码

/*
 * Copyright (c) 1998-2008 Caucho Technology -- all rights reserved
 *
 * This file is part of Resin(R) Open Source
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Resin Open Source is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2
 * as published by the Free Software Foundation.
 *
 * Resin Open Source 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, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Resin Open Source; if not, write to the
 *
 *   Free Software Foundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Scott Ferguson
 */

package javax.faces.component;

import java.util.*;
import java.util.logging.*;

import javax.el.*;

import javax.faces.*;
import javax.faces.application.*;
import javax.faces.context.*;
import javax.faces.convert.*;
import javax.faces.el.*;
import javax.faces.event.*;
import javax.faces.render.*;
import javax.faces.validator.*;

public class UIInput extends UIOutput
  implements EditableValueHolder
{
  private static final Logger log
    = Logger.getLogger(UIInput.class.getName());
  
  public static final String COMPONENT_FAMILY = "javax.faces.Input";
  public static final String COMPONENT_TYPE = "javax.faces.Input";
  
  public static final String CONVERSION_MESSAGE_ID
    = "javax.faces.component.UIInput.CONVERSION";
  public static final String REQUIRED_MESSAGE_ID
    = "javax.faces.component.UIInput.REQUIRED";
  public static final String UPDATE_MESSAGE_ID
    = "javax.faces.component.UIInput.UPDATE";

  private static final Validator []NULL_VALIDATORS = new Validator[0];
  
  private static final HashMap<String,PropEnum> _propMap
    = new HashMap<String,PropEnum>();

  private ValueExpression _valueExpr;
  
  private Boolean _required;
  private ValueExpression _requiredExpr;
  
  private Boolean _immediate;
  private ValueExpression _immediateExpr;

  private String _requiredMessage;
  private ValueExpression _requiredMessageExpr;

  private String _converterMessage;
  private ValueExpression _converterMessageExpr;

  private String _validatorMessage;
  private ValueExpression _validatorMessageExpr;

  //

  private boolean _isValid = true;
  private boolean _isLocalValueSet;

  private Object _submittedValue;

  private ArrayList<Validator> _validatorList;
  private Validator []_validators = NULL_VALIDATORS;

  public UIInput()
  {
    setRendererType("javax.faces.Text");
  }

  /**
   * Returns the component family, used to select the renderer.
   */
  public String getFamily()
  {
    return COMPONENT_FAMILY;
  }

  //
  // properties
  //

  public String getRequiredMessage()
  {
    if (_requiredMessage != null)
      return _requiredMessage;
    else if (_requiredMessageExpr != null)
      return Util.evalString(_requiredMessageExpr, getFacesContext());
    else
      return null;
  }

  public void setRequiredMessage(String value)
  {
    _requiredMessage = value;
  }

  public String getConverterMessage()
  {
    if (_converterMessage != null)
      return _converterMessage;
    else if (_converterMessageExpr != null)
      return Util.evalString(_converterMessageExpr, getFacesContext());
    else
      return null;
  }

  public void setConverterMessage(String value)
  {
    _converterMessage = value;
  }

  public String getValidatorMessage()
  {
    if (_validatorMessage != null)
      return _validatorMessage;
    else if (_validatorMessageExpr != null)
      return Util.evalString(_validatorMessageExpr, getFacesContext());
    else
      return null;
  }

  public void setValidatorMessage(String value)
  {
    _validatorMessage = value;
  }

  /**
   * Returns the value expression with the given name.
   */
  @Override
  public ValueExpression getValueExpression(String name)
  {
    PropEnum prop = _propMap.get(name);

    if (prop != null) {
      switch (_propMap.get(name)) {
      case VALUE:
	return _valueExpr;
      case IMMEDIATE:
	return _immediateExpr;
      case REQUIRED:
	return _requiredExpr;
      case REQUIRED_MESSAGE:
	return _requiredMessageExpr;
      case CONVERTER_MESSAGE:
	return _converterMessageExpr;
      case VALIDATOR_MESSAGE:
	return _validatorMessageExpr;
      }
    }

    return super.getValueExpression(name);
  }

  /**
   * Sets the value expression with the given name.
   */
  @Override
  public void setValueExpression(String name, ValueExpression expr)
  {
    PropEnum prop = _propMap.get(name);

    if (prop != null) {
      switch (_propMap.get(name)) {
      case VALUE:
	if (expr != null && ! expr.isLiteralText())
	  _valueExpr = expr;
	break;
	
      case IMMEDIATE:
	if (expr != null && expr.isLiteralText()) {
	  _immediate = (Boolean) expr.getValue(null);
	  return;
	}
	else
	  _immediateExpr = expr;
	break;
	
      case REQUIRED:
	if (expr != null && expr.isLiteralText()) {
	  _required = (Boolean) expr.getValue(null);
	  return;
	}
	else
	  _requiredExpr = expr;
	break;
	
      case REQUIRED_MESSAGE:
	if (expr != null && expr.isLiteralText()) {
	  _requiredMessage = (String) expr.getValue(null);
	  return;
	}
	else
	  _requiredMessageExpr = expr;
	break;
	
      case CONVERTER_MESSAGE:
	if (expr != null && expr.isLiteralText()) {
	  _converterMessage = (String) expr.getValue(null);
	  return;
	}
	else
	  _converterMessageExpr = expr;
	break;
	
      case VALIDATOR_MESSAGE:
	if (expr != null && expr.isLiteralText()) {
	  _validatorMessage = (String) expr.getValue(null);
	  return;
	}
	else
	  _validatorMessageExpr = expr;
	break;
      }
    }

    super.setValueExpression(name, expr);
  }

  //
  // EditableValueHolder properties.
  //

  public boolean isRequired()
  {
    if (_required != null)
      return _required;
    else if (_requiredExpr != null)
      return Util.evalBoolean(_requiredExpr, getFacesContext());
    else
      return false;
  }

  public void setRequired(boolean required)
  {
    _required = required;
  }

  public boolean isImmediate()
  {
    if (_immediate != null)
      return _immediate;
    else if (_immediateExpr != null)
      return Util.evalBoolean(_immediateExpr, getFacesContext());
    else
      return false;
  }

  public void setImmediate(boolean immediate)
  {
    _immediate = immediate;
  }

  public Object getSubmittedValue()
  {
    return _submittedValue;
  }

  public void setSubmittedValue(Object submittedValue)
  {
    _submittedValue = submittedValue;
  }

  public void setValue(Object value)
  {
    super.setValue(value);

    setLocalValueSet(true);
  }

  public boolean isLocalValueSet()
  {
    return _isLocalValueSet;
  }

  public void setLocalValueSet(boolean isSet)
  {
    _isLocalValueSet = isSet;
  }

  public void resetValue()
  {
    setValue(null);
    setSubmittedValue(null);
    setLocalValueSet(false);
    setValid(true);
  }

  public boolean isValid()
  {
    return _isValid;
  }
  
  public void setValid(boolean valid)
  {
    _isValid = valid;
  }

  @Deprecated
  public MethodBinding getValueChangeListener()
  {
    FacesListener []listeners = getFacesListeners(FacesListener.class);
    for (int i = 0; i < listeners.length; i++) {
      if (listeners[i] instanceof ValueChangeListenerAdapter) {
	ValueChangeListenerAdapter adapter
	  = (ValueChangeListenerAdapter) listeners[i];

	return adapter.getBinding();
      }
    }

    return null;
  }

  @Deprecated
  public void setValueChangeListener(MethodBinding binding)
  {
    ValueChangeListener listener
      = new ValueChangeListenerAdapter(binding);

    FacesListener []listeners = getFacesListeners(FacesListener.class);
    for (int i = 0; i < listeners.length; i++) {
      if (listeners[i] instanceof ValueChangeListenerAdapter) {
	removeFacesListener(listeners[i]);
      }
    }
    
    addValueChangeListener(listener);
  }

  public void addValidator(Validator validator)
  {
    Validator []newValidators = new Validator[_validators.length + 1];
    System.arraycopy(_validators, 0, newValidators, 0, _validators.length);
    newValidators[_validators.length] = validator;

    _validators = newValidators;
  }

  public void removeValidator(Validator validator)
  {
    int length = _validators.length;
    for (int i = 0; i < length; i++) {
      if (_validators[i] == validator) {
	Validator []newValidators = new Validator[length - 1];
	System.arraycopy(_validators, 0, newValidators, 0, i);
	System.arraycopy(_validators, i + 1, newValidators, i, length - i - 1);
	_validators = newValidators;
	return;
      }
    }
  }

  public Validator []getValidators()
  {
    return _validators;
  }

  @Deprecated
  public MethodBinding getValidator()
  {
    int length = _validators.length;
    for (int i = 0; i < length; i++) {
      Validator validator = _validators[i];

      if (validator instanceof ValidatorAdapter) {
	ValidatorAdapter adapter = (ValidatorAdapter) validator;

	return adapter.getBinding();
      }
    }

    return null;
  }

  @Deprecated
  public void setValidator(MethodBinding binding)
  {
    ValidatorAdapter adapter = new ValidatorAdapter(binding);
    
    int length = _validators.length;
    for (int i = 0; i < length; i++) {
      Validator validator = _validators[i];

      if (validator instanceof ValidatorAdapter) {
	_validators[i] = adapter;
	return;
      }
    }

    addValidator(adapter);
  }

  public void addValueChangeListener(ValueChangeListener listener)
  {
    addFacesListener(listener);
  }
  
  public void removeValueChangeListener(ValueChangeListener listener)
  {
    removeFacesListener(listener);
  }
  
  public ValueChangeListener []getValueChangeListeners()
  {
    return
      (ValueChangeListener []) getFacesListeners(ValueChangeListener.class);
  }

  //
  // processing
  //

  @Override
  public void decode(FacesContext context)
  {
    setValid(true);
    super.decode(context);
  }

  public void processDecodes(FacesContext context)
  {
    if (isRendered()) {
      super.processDecodes(context);

      if (isImmediate()) {
	try {
	  validate(context);
	} catch (RuntimeException e) {
	  context.renderResponse();

	  throw e;
	}

	if (! isValid())
	  context.renderResponse();
      }
    }
  }

  public void processUpdates(FacesContext context)
  {
    if (isRendered()) {
      super.processUpdates(context);