import javax.faces.component.EditableValueHolder; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public void decode(FacesContext context, UIComponent component)
{
  _addChildren(context, component);

  Map<String, Object> attrs = component.getAttributes();
  if (Boolean.TRUE.equals(attrs.get("readOnly")) ||
      Boolean.TRUE.equals(attrs.get("disabled")))
    return;

  // Just clue in component that we have been "submitted" so
  // that it doesn't short-circuit anything
  EditableValueHolder evh = (EditableValueHolder) component;
  evh.setSubmittedValue(Boolean.TRUE);

  // Because these components weren't around during processDecodes(),
  // they didn't get decoded.  So, run that now.
  component.getFacet("month").processDecodes(context);
  component.getFacet("year").processDecodes(context);
  component.getFacet("day").processDecodes(context);
}
 

import javax.faces.component.EditableValueHolder; //导入依赖的package包/类
private static RowState _createState(UIComponent child)
{
  RowState state;
  if (child instanceof EditableValueHolder)
  {
    state = new EVHState();
    state.saveRowState(child);
  }
  else if (child instanceof UIXCollection)
  {
    state = new TableState();
    state.saveRowState(child);
  }
  else if (child instanceof UIXShowDetail)
  {
    state = SDState.getState((UIXShowDetail) child);
  }
  else
  {
    state = null;
  }

  return state;
}
 

import javax.faces.component.EditableValueHolder; //导入依赖的package包/类
@Override
public VisitResult visit(VisitContext context, UIComponent target) {
	FacesContext facesContext = context.getFacesContext();
	Collection<String> executeIds = facesContext.getPartialViewContext().getExecuteIds();

	if (executeIds.contains(target.getClientId(facesContext))) {
		return VisitResult.REJECT;
	}

	if (target instanceof EditableValueHolder) {
		((EditableValueHolder) target).resetValue();
	}
	else if (context.getIdsToVisit() != VisitContext.ALL_IDS) {
		// Render ID didn't specifically point an EditableValueHolder. Visit all children as well.
		if (!SKIP_COMPONENTS.contains(target.getClass())) {
			try {
				target.visitTree(createVisitContext(facesContext, null, context.getHints()), VISIT_CALLBACK);
			} catch (Exception e) {
				// e.printStackTrace();
			}
		}
	}

	return VisitResult.ACCEPT;
}
 

import javax.faces.component.EditableValueHolder; //导入依赖的package包/类
private void saveChildState(FacesContext faces, UIComponent c) {

		if (c instanceof EditableValueHolder && !c.isTransient()) {
			String clientId = c.getClientId(faces);
			SavedState ss = this.getChildState().get(clientId);
			if (ss == null) {
				ss = new SavedState();
				this.getChildState().put(clientId, ss);
			}
			ss.populate((EditableValueHolder) c);
		}

		// continue hack
		Iterator itr = c.getFacetsAndChildren();
		while (itr.hasNext()) {
			saveChildState(faces, (UIComponent) itr.next());
		}
	}
 

import javax.faces.component.EditableValueHolder; //导入依赖的package包/类
/**
 * Walk the component tree branch built by the composite component and locate the input container elements.
 *
 * @return a composite object of the input container elements
 */
protected InputContainerElements scan(final UIComponent component, InputContainerElements elements,
                                      final FacesContext context) {
    if (elements == null) {
        elements = new InputContainerElements();
    }

    // NOTE we need to walk the tree ignoring rendered attribute because it's condition
    // could be based on what we discover
    if ((elements.getLabel() == null) && (component instanceof HtmlOutputLabel)) {
        elements.setLabel((HtmlOutputLabel) component);
    } else if (component instanceof EditableValueHolder) {
        elements.registerInput((EditableValueHolder) component, getDefaultValidator(context), context);
    } else if (component instanceof UIMessage) {
        elements.registerMessage((UIMessage) component);
    }
    // may need to walk smarter to ensure "element of least suprise"
    for (UIComponent child : component.getChildren()) {
        scan(child, elements, context);
    }

    return elements;
}
 

import javax.faces.component.EditableValueHolder; //导入依赖的package包/类
public void registerInput(final EditableValueHolder input, final Validator validator, final FacesContext context) {
    inputs.add(input);

    if (!input.isValid()) {
        validationError = true;
    }
    // optimization to avoid loop if already flagged
    else if (!validationError) {
        Iterator<FacesMessage> it = context.getMessages(((UIComponent) input).getClientId(context));
        while (it.hasNext()) {
            if (it.next().getSeverity().compareTo(FacesMessage.SEVERITY_WARN) >= 0) {
                validationError = true;
                break;
            }
        }
    }
}
 

import javax.faces.component.EditableValueHolder; //导入依赖的package包/类
@Override
protected void decode(
  FacesContext facesContext,
  UIComponent  component,
  @SuppressWarnings("unused")
  FacesBean    facesBean,
  String       clientId)
{
  if (skipDecode(facesContext))
    return;

  Object submittedValue;
  if (!wasSubmitted(facesContext, component))
    submittedValue = null;
  else
  {
    if (clientId == null)
    {
      clientId = component.getClientId(facesContext);
    }
    submittedValue = getSubmittedValue(facesContext, component, clientId);
  }

  if (_LOG.isFinest())
  {
    if (clientId == null)
    {
      clientId = component.getClientId(facesContext);
    }
    _LOG.finest("Value submitted for ID {0} is {1}",
      new Object[]{clientId, submittedValue});
  }

  EditableValueHolder evh = (EditableValueHolder) component;
  evh.setSubmittedValue(submittedValue);
}
 

import javax.faces.component.EditableValueHolder; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private void _resetChildren(UIComponent comp)
{
  Iterator<UIComponent> kids = comp.getFacetsAndChildren();

  while (kids.hasNext())
  {
    UIComponent kid = kids.next();
    
    if (kid instanceof UIXEditableValue)
    {
      ((UIXEditableValue) kid).resetValue();
      RequestContext.getCurrentInstance().addPartialTarget(kid);
    }
    else if (kid instanceof EditableValueHolder)
    {
      _resetEditableValueHolder((EditableValueHolder) kid);
      RequestContext.getCurrentInstance().addPartialTarget(kid);
    }
    else if (kid instanceof UIXCollection)
    {
      ((UIXCollection) kid).resetStampState();
      RequestContext.getCurrentInstance().addPartialTarget(kid);
    }

    _resetChildren(kid);
  }
}
 

import javax.faces.component.EditableValueHolder; //导入依赖的package包/类
private void _resetEditableValueHolder(EditableValueHolder evh)
{
  evh.setValue(null);
  evh.setSubmittedValue(null);
  evh.setLocalValueSet(false);
  evh.setValid(true);
}
 

import javax.faces.component.EditableValueHolder; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private void _addChildren(FacesContext context, UIComponent component)
{
  // If the components are already there, bail.
  if (component.getFacet("month") != null)
    return;

  String id = component.getId();
  if (id == null)
  {
    id = context.getViewRoot().createUniqueId();
    component.setId(id);
  }

  Map<String, UIComponent> facets = component.getFacets();
  facets.clear();

  Date value = (Date) ((EditableValueHolder) component).getValue();
  Calendar calendar = null;
  if(value != null)
  {
    calendar = Calendar.getInstance();
    calendar.setLenient(true);
    calendar.setTime(value);
  }

  CoreInputText month = _createTwoDigitInput(context);
  month.setShortDesc("Month");
  month.setId(id + "_month");

  LongRangeValidator monthRange = _createLongRangeValidator(context);
  monthRange.setMinimum(1);
  monthRange.setMaximum(12);
  month.addValidator(monthRange);
  if (value != null)
    month.setValue(new Integer(calendar.get(Calendar.MONTH) + 1));
  facets.put("month", month);

  CoreInputText day = _createTwoDigitInput(context);
  day.setShortDesc("Day");
  day.setId(id + "_day");
  LongRangeValidator dayRange = _createLongRangeValidator(context);
  dayRange.setMinimum(1);
  dayRange.setMaximum(31);
  day.addValidator(dayRange);
  if (value != null)
    day.setValue(new Integer(calendar.get(Calendar.DAY_OF_MONTH)));
  facets.put("day", day);

  CoreInputText year = _createTwoDigitInput(context);
  year.setShortDesc("Year");
  year.setId(id + "_year");
  if (value != null)
  {
    int yearValue = calendar.get(Calendar.YEAR) - 1900;
    if (yearValue >= 100)
      yearValue -= 100;
    year.setValue(new Integer(yearValue));
  }

  facets.put("year", year);
}
 

import javax.faces.component.EditableValueHolder; //导入依赖的package包/类
@Override
public int doStartTag() throws JspException
{
    UIComponentClassicTagBase componentTag = UIComponentELTag.getParentUIComponentClassicTagBase(pageContext);

    if (componentTag == null)
    {
        throw new JspException("no parent UIComponentTag found");
    }

    if (!componentTag.getCreated())
    {
        return Tag.SKIP_BODY;
    }

    Validator validator = createValidator();

    UIComponent component = componentTag.getComponentInstance();
    if (component == null)
    {
        throw new JspException("parent UIComponentTag has no UIComponent");
    }

    if (!(component instanceof EditableValueHolder))
    {
        throw new JspException("UIComponent is no EditableValueHolder");
    }
    ((EditableValueHolder)component).addValidator(validator);

    return Tag.SKIP_BODY;
}
 

import javax.faces.component.EditableValueHolder; //导入依赖的package包/类
private boolean _assertStampHonoursState(EditableValueHolder evh)
{
  return (evh.getSubmittedValue() == _submitted) &&
    (evh.getLocalValue() == _local) &&
    (evh.isLocalValueSet() == _localSet) &&
    (evh.isValid() == _valid);
}
 

import javax.faces.component.EditableValueHolder; //导入依赖的package包/类
/**
 * Tests the update-model-values lifecycle phase.
 */
protected void doTestUpdateModelValues(
  UIViewRoot  root,
  UIComponent component)
{

  Mock mockRenderkit = getMockRenderKitWrapper().getMock();

  Mock mockRenderer = mock(Renderer.class);
  Renderer renderer = (Renderer) mockRenderer.proxy();
  mockRenderkit.stubs().method("getRenderer").will(returnValue(renderer));

  Mock mockBinding = mock(ValueBinding.class);
  ValueBinding binding = (ValueBinding) mockBinding.proxy();

  setCurrentContext(facesContext);

  // if the component is an EditableValueHolder, then the value binding
  // must be updated with the new value before this phase completes.
  if (component instanceof EditableValueHolder)
  {
    EditableValueHolder editable = (EditableValueHolder)component;
    component.setValueBinding("value", binding);
    editable.setValue("newValue");
    mockBinding.expects(atLeastOnce()).method("setValue").with(eq(facesContext), eq("newValue"));

    assertEquals(true, editable.isLocalValueSet());
  }

  doTestUpdateModelValues(facesContext, root, component);

  setCurrentContext(null);

  mockRenderer.verify();
  mockBinding.verify();
}
 

import javax.faces.component.EditableValueHolder; //导入依赖的package包/类
private void _setEVHData(
  EditableValueHolder testComp,
  String value,
  boolean isValid)
{
  testComp.setSubmittedValue("submitedValue-"+value);
  testComp.setValue("Value-"+value);
  testComp.setValid(isValid);
}
 

import javax.faces.component.EditableValueHolder; //导入依赖的package包/类
private void _testEVHData(
  EditableValueHolder testComp,
  String value,
  boolean isValid)
{
  assertEquals("submitedValue-"+value, testComp.getSubmittedValue());
  assertEquals("Value-"+value, testComp.getLocalValue());
  assertEquals(isValid, testComp.isValid());
}
 

import javax.faces.component.EditableValueHolder; //导入依赖的package包/类
public static String getValueToRender(FacesContext context, UIComponent component) {
	if (component instanceof ValueHolder) {

		if (component instanceof EditableValueHolder) {
			EditableValueHolder input = (EditableValueHolder) component;
			Object submittedValue = input.getSubmittedValue();

			if (submittedValue == null && context.isValidationFailed() && !input.isValid()) {
				return null;
			} else if (submittedValue != null) {
				return submittedValue.toString();
			}
		}

		ValueHolder valueHolder = (ValueHolder) component;
		Object value = valueHolder.getValue();

		// format the value as string
		if (value != null) {
			return value.toString();
		} else {
			// component is a value holder but has no value
			return null;
		}
	}

	// component is not a value holder
	return null;
}
 

import javax.faces.component.EditableValueHolder; //导入依赖的package包/类
/** 
 * Save the new paging state back to the given component (adjusting firstItem and lastItem first if necessary)
 */
private static void adjustState(FacesContext context, UIComponent component, int firstItem, int lastItem, int pageSize, int totalItems, int newFirstItem, int newLastItem, int newPageSize)
{
	// recalculate last item
	newLastItem = Math.min(newFirstItem + newPageSize, totalItems);
	if (newPageSize <= 0) 
	{
		// if displaying all items
		newFirstItem = 0;
		newLastItem = totalItems;
	}

	// we don't count lastItem changing as a full state change (value of this component doesn't change)
    if (newLastItem != lastItem) RendererUtil.setAttribute(context, component, "lastItem", new Integer(newLastItem));

    // send the newly changed values where they need to go
	if (newPageSize != pageSize) RendererUtil.setAttribute(context, component, "pageSize", new Integer(newPageSize));
	if (newFirstItem != firstItem) RendererUtil.setAttribute(context, component, "firstItem", new Integer(newFirstItem));
    	
	// Set value, which causes registered valueChangeListener to be called
	EditableValueHolder evh = (EditableValueHolder) component;
	String newValue = formatValue(newFirstItem, newPageSize);
	Object oldValue = (String)evh.getValue();
	if (!newValue.equals(oldValue))
	{
		if (oldValue != null) {
			evh.setSubmittedValue(newValue);
			evh.setValid(true);
		} else {
			// Need to initialize value string based on initial parameters.
			if (log.isDebugEnabled()) log.debug("initializing value to " + newValue);
			evh.setValue(newValue);
		}
	}
}
 

import javax.faces.component.EditableValueHolder; //导入依赖的package包/类
private void restoreChildState(FacesContext faces, UIComponent c) {
	// reset id
	String id = c.getId();
	c.setId(id);

	// hack
	if (c instanceof EditableValueHolder) {
		EditableValueHolder evh = (EditableValueHolder) c;
		String clientId = c.getClientId(faces);
		SavedState ss = this.getChildState().get(clientId);
		if (ss != null) {
			ss.apply(evh);
		} else {
			String childId = clientId.substring(initialClientId.length() + 1);
			childId = childId.substring(childId.indexOf(getSeparatorChar(faces)) + 1);
			childId = initialClientId + getSeparatorChar(faces) + childId;
			if (initialChildState.containsKey(childId)) {
				SavedState initialState = initialChildState.get(childId);
				initialState.apply(evh);
			} else {
				NullState.apply(evh);
			}
		}
	}

	// continue hack
	Iterator itr = c.getFacetsAndChildren();
	while (itr.hasNext()) {
		restoreChildState(faces, (UIComponent) itr.next());
	}
}
 

import javax.faces.component.EditableValueHolder; //导入依赖的package包/类
/**
 * Recursively create the initial state for the given component.
 * 
 * @param facesContext
 *            the Faces context.
 * @param component
 *            the UI component to save the state for.
 * @see #saveInitialChildState(javax.faces.context.FacesContext)
 */
private void saveInitialChildState(FacesContext facesContext, UIComponent component) {
	if (component instanceof EditableValueHolder && !component.isTransient()) {
		String clientId = component.getClientId(facesContext);
		SavedState state = new SavedState();
		initialChildState.put(clientId, state);
		state.populate((EditableValueHolder) component);
	}

	Iterator<UIComponent> iterator = component.getFacetsAndChildren();
	while (iterator.hasNext()) {
		saveChildState(facesContext, iterator.next());
	}
}
 

import javax.faces.component.EditableValueHolder; //导入依赖的package包/类
@Override
    public void decode(FacesContext context, UIComponent component) {
        // SPR # LHEY9QHH58
        // Ensure that when a parent panel control is read-only
        // that we do not save "" (empty string) as the current field value.
//            super.decode(context, component);
        
        // We should reset the submitted value as it might be validated otherwise
        if(component instanceof EditableValueHolder) {
            ((EditableValueHolder)component).setSubmittedValue(null);
        }
    }