uicomponentbase.java

RESIN 3.2 最新源码

	array[count++] = _facesListeners[i];
      }
    }

    return array;
  }

  protected void removeFacesListener(FacesListener listener)
  {
    if (listener == null)
      throw new NullPointerException();

    int length = _facesListeners.length;
    for (int i = 0; i < length; i++) {
      if (listener.equals(_facesListeners[i])) {
	FacesListener []newListeners = new FacesListener[length - 1];
	System.arraycopy(_facesListeners, 0, newListeners, 0, i);
	System.arraycopy(_facesListeners, i + 1, newListeners, i,
			 length - i - 1);

	_facesListeners = newListeners;

	return;
      }
    }
  }

  public void queueEvent(FacesEvent event)
  {
    UIComponent parent = getParent();

    if (parent != null)
      parent.queueEvent(event);
    else
      throw new IllegalStateException();
  }

  public void broadcast(FacesEvent event)
    throws AbortProcessingException
  {
    for (int i = 0; i < _facesListeners.length; i++) {
      if (event.isAppropriateListener(_facesListeners[i])) {
	event.processListener(_facesListeners[i]);
      }
    }
  }

  //
  // decoding
  //

  /**
   * Recursively calls the decodes for any children, then calls
   * decode().
   */
  public void processDecodes(FacesContext context)
  {
    if (context == null)
      throw new NullPointerException();

    if (! isRendered())
      return;

    for (UIComponent child : getFacetsAndChildrenArray()) {
      child.processDecodes(context);
    }

    try {
      decode(context);
    } catch (RuntimeException e) {
      log.log(Level.WARNING, e.toString(), e);
      
      context.renderResponse();

      throw e;
    }
  }

  /**
   * Decodes the value of the component.
   */
  @Override
  public void decode(FacesContext context)
  {
    Renderer renderer = getRenderer(context);

    if (renderer != null)
      renderer.decode(context, this);
  }

  //
  // Validation
  //

  @Override
  public void processValidators(FacesContext context)
  {
    if (context == null)
      throw new NullPointerException();

    if (! isRendered())
      return;

    for (UIComponent child : getFacetsAndChildrenArray()) {
      child.processValidators(context);
    }
  }

  //
  // Model updates
  //

  public void processUpdates(FacesContext context)
  {
    if (context == null)
      throw new NullPointerException();

    if (! isRendered())
      return;

    for (UIComponent child : getFacetsAndChildrenArray()) {
      child.processUpdates(context);
    }
  }

  //
  // Encoding
  //

  /**
   * Starts the output rendering for the encoding.
   */
  public void encodeBegin(FacesContext context)
    throws IOException
  {
    if (context == null)
      throw new NullPointerException();

    if (! isRendered())
      return;

    try {
      Renderer renderer = getRenderer(context);

      if (renderer != null)
	renderer.encodeBegin(context, this);

    } catch (IOException e) {
      if (e.getMessage().startsWith("id="))
	throw e;
      else
	throw new IOExceptionWrapper("id=" + getClientId(context)
				     + " " + e.toString(), e);
    } catch (RuntimeException e) {
      if (e.getMessage() != null
	  && e.getMessage().startsWith("id="))
	throw e;
      else
	throw new FacesException("id=" + getClientId(context)
				 + " " + e.toString(), e);
    }
  }

  public void encodeChildren(FacesContext context)
    throws IOException
  {
    if (context == null)
      throw new NullPointerException();

    if (! isRendered())
      return;

    Renderer renderer = getRenderer(context);

    if (renderer != null)
      renderer.encodeChildren(context, this);
  }

  public void encodeEnd(FacesContext context)
    throws IOException
  {
    if (context == null)
      throw new NullPointerException();

    if (! isRendered())
      return;

    Renderer renderer = getRenderer(context);

    if (renderer != null)
      renderer.encodeEnd(context, this);
  }

  @Override
  protected FacesContext getFacesContext()
  {
    return FacesContext.getCurrentInstance();
  }

  @Override
  protected Renderer getRenderer(FacesContext context)
  {
    String rendererType = getRendererType();

    if (rendererType == null)
      return null;
    
    RenderKit renderKit = context.getRenderKit();

    if (renderKit != null)
      return renderKit.getRenderer(getFamily(), getRendererType());
    else
      return null;
  }

  //
  // Save the state of the component
  //

  public Object processSaveState(FacesContext context)
  {
    if (context == null)
      throw new NullPointerException();

    if (isTransient())
      return null;
    
    UIComponent []facetsAndChildren = getFacetsAndChildrenArray();

    Object []childSaveState = null;

    int childSize = getChildCount();
    int facetSize = getFacetCount();
    int k = 1;
      
    if (childSize > 0) {
      List<UIComponent> children = getChildren();
      
      for (int i = 0; i < childSize; i++) {
	UIComponent child = children.get(i);

	if (child.isTransient())
	  continue;
	
	k++;
	
	Object childState = child.processSaveState(context);

	if (childState != null) {
	  if (childSaveState == null)
	    childSaveState = new Object[1 + childSize + 2 * facetSize];
      
	  childSaveState[k - 1] = childState;
	}
      }
    }

    if (facetSize > 0) {
      Map<String,UIComponent> facetMap = getFacets();

      for (Map.Entry<String,UIComponent> entry : facetMap.entrySet()) {
	UIComponent facet = entry.getValue();

	if (facet.isTransient())
	  continue;
	
	k += 2;

	Object facetState = facet.processSaveState(context);

	if (facetState != null) {
	  if (childSaveState == null)
	    childSaveState = new Object[1 + childSize + 2 * facetSize];
      
	  childSaveState[k - 2] = entry.getKey();
	  childSaveState[k - 1] = facetState;
	}
      }
    }

    Object selfSaveState = saveState(context);

    if (childSaveState != null) {
      childSaveState[0] = selfSaveState;
      return childSaveState;
    }
    else
      return new Object[] { selfSaveState };
  }

  public void processRestoreState(FacesContext context,
				  Object state)
  {
    if (context == null)
      throw new NullPointerException();

    if (isTransient())
      return;

    UIComponent []facetsAndChildren = getFacetsAndChildrenArray();

    Object []baseState = (Object []) state;

    if (baseState == null)
      return;

    restoreState(context, baseState[0]);

    if (baseState.length == 1)
      return;

    int childSize = getChildCount();
    int facetSize = getFacetCount();
    int k = 1;
      
    if (childSize > 0) {
      List<UIComponent> children = getChildren();
      
      for (int i = 0; i < childSize; i++) {
	UIComponent child = children.get(i);

	if (child.isTransient()) {
	  continue;
	}
	
	k++;
	
	Object childState;
	
	if (k <= baseState.length)
	  childState = baseState[k - 1];
	else
	  childState = null;

	if (childState != null)
	  child.processRestoreState(context, childState);
      }
    }
      
    if (facetSize > 0) {
      Map<String,UIComponent> facetMap = getFacets();

      for (; k < baseState.length; k += 2) {
	String facetName = (String) baseState[k];
	Object facetState = baseState[k + 1];

	if (facetName != null && facetState != null) {
	  UIComponent facet = facetMap.get(facetName);

	  if (facet != null)
	    facet.processRestoreState(context, facetState);
	}
      }
    }
  }
  
  public Object saveState(FacesContext context)
  {
    Integer rendererCode = _rendererToCodeMap.get(_rendererType);
    String rendererString = null;

    if (rendererCode == null)
      rendererString = _rendererType;

    Object []savedListeners = saveListeners(context);

    Object []savedBindings = saveBindings(context);
    
    return new Object[] {
      _id,
      savedBindings,
      _isRendered,
      rendererCode,
      rendererString,
      (_attributeMap != null ? _attributeMap.saveState(context) : null),
      savedListeners,
    };
  }

  private Object []saveBindings(FacesContext context) {
    if (_bindings == null)
      return null;

    Set<String> keys = _bindings.keySet();
    Object [] result = new Object [keys.size() * 2];

    int index = 0;
    for (String key : keys) {
      result [index++] = key;

      ValueExpression valueExpression = _bindings.get(key);

      result [index++] = saveAttachedState(context, valueExpression);
    }

    return result;
  }

  private void restoreBindings(FacesContext context, Object stateObj) {
    Object [] state = (Object []) stateObj;

    if (state.length == 0) return;

    _bindings = new HashMap<String, ValueExpression>();


    for (int i = 0; i < state.length / 2; i++) {
      int index = i * 2;

      String key = (String) state[index];

      ValueExpression valueExpression 
        = (ValueExpression) restoreAttachedState(context, state [index + 1]);

      _bindings.put(key, valueExpression);
    }
  }

  private Object []saveListeners(FacesContext context)
  {
    if (_facesListeners.length > 0) {
      Object []savedListeners = new Object[2 * _facesListeners.length];

      for (int i = 0; i < _facesListeners.length; i++) {
	FacesListener listener = _facesListeners[i];

	int index = 2 * i;
	
	savedListeners[index] = listener.getClass();

	if (listener instanceof StateHolder) {
	  StateHolder holder = (StateHolder) listener;
	  
	  savedListeners[index + 1] = holder.saveState(context);
	}
      }

      return savedListeners;
    }

    return null;
  }

  public void restoreState(FacesContext context, Object stateObj)
  {
    Object []state = (Object []) stateObj;

    _id = (String) state[0];

    Object []savedBindings = (Object[]) state[1];

    if (savedBindings != null)
      restoreBindings(context, savedBindings);

    if (_bindings != null) {
      for (Map.Entry<String,ValueExpression> entry : _bindings.entrySet()) {
	setValueExpression(entry.getKey(), entry.getValue());
      }
    }

    _isRendered = (Boolean) state[2];

    Integer rendererCode = (Integer) state[3];
    String rendererString = (String) state[4];

    if (rendererCode != null)
      _rendererType = _codeToRendererMap.get(rendererCode);
    else
      _rendererType = rendererString;
	
    Object extMapState = state[5];

    if (extMapState != null) {
      if (_attributeMap == null)
	_attributeMap = new AttributeMap(this);

      _attributeMap.restoreState(context, extMapState);
    }

    Object []savedListeners = (Object []) state[6];

    restoreListeners(context, savedListeners);
  }

  private void restoreListeners(FacesContext context, Object []savedListeners)
  {
    if (savedListeners != null) {
      _facesListeners = new FacesListener[savedListeners.length / 2];

      for (int i = 0; i < _facesListeners.length; i++) {
	int index = 2 * i;
	
	Class cl = (Class) savedListeners[index];