uidata.java

一个使用struts+hibernate+spring开发的完的网站源代码。

				{
					UIData childUIData = (UIData) child;
					Object state =
						_rowState._clientIdsToChildUIDataStates.get(
							childUIData.getClientId(context));
					if (state == null)
					{
						UIDataRowState initialState =
							(UIDataRowState) _rowState._clientIdsToChildUIDataStates.get(getInitialClientId(context, child));

						if (initialState == null)
						{
							throw new IllegalStateException(
								"No initial state defined for clientId: " + child.getClientId(context));
						}

						state = new UIDataRowState(initialState);
					}



					childUIData._rowState = (UIDataRowState) state;

					restoreDescendantComponentStates(context, component, false);
					continue;
				}

				if (!_firstTimeRendered && child instanceof EditableValueHolder)
				{
					EditableValueHolder childEVH = (EditableValueHolder) child;
					Object state =
						_rowState._clientIdsToChildEVHStates.get(child.getClientId(context));
					if (state == null)
					{
						state =
							_rowState._clientIdsToChildEVHStates.get(
								getInitialClientId(context, child));
					}
					((EditableValueHolderState) state).restore(childEVH);
				}
			}

			restoreDescendantComponentStates(context, child, saveState);
		}
	}

	//    private void restoreDescendantComponentStates()
	//    {
	//        if (_descendantEditableValueHolderCount == -1)
	//        {
	//            throw new IllegalStateException("saveDescendantComponentStates not called yet?");
	//        }
	//        else if (_descendantEditableValueHolderCount > 0)
	//        {
	//            // There is at least one descendant component to be restored
	//
	//            // Get zero-based index (instead of -1 based UIData zeroBasedRowIdx):
	//            int zeroBasedRowIdx = getDescendantStatesRowIndex();
	//
	//            // Is there a reason to restore the state of a new descendant?
	//            // BUG: 925693
	//            // manolito: Yes, descendants for a row not yet saved, must be
	//            //           reset to initial row state!
	//            int stateRowsCount = _descendantStates.length;
	//
	//            EditableValueHolderState[] initialStates = null;
	//            if (stateRowsCount > 0)
	//            {
	//                // No state saved yet for this row, let's restore initial values:
	//                initialStates = (EditableValueHolderState[]) _descendantStates[0];
	//            }
	//
	//            if (zeroBasedRowIdx < stateRowsCount)
	//            {
	//                // There is a saved state for this row, so restore these values:
	//                EditableValueHolderState[] rowState =
	//                    (EditableValueHolderState[]) _descendantStates[zeroBasedRowIdx];
	//                restoreDescendantComponentStates(this, rowState, initialStates, 0, 0);
	//            }
	//            else
	//            {
	//                // No state saved yet for this row, let's restore initial values:
	//                restoreDescendantComponentStates(this, initialStates, initialStates, 0, 0);
	//            }
	//        }
	//        else
	//        {
	//            // There are no states to restore, so only recurse to set the
	//            // right clientIds for all descendants
	//            restoreDescendantComponentStates(this, null, null, 0, 0);
	//        }
	//    }

	//    private static int restoreDescendantComponentStates(UIComponent component,
	//                                                        EditableValueHolderState[] states,
	//                                                        EditableValueHolderState[] initialStates,
	//                                                        int counter, int level)
	//    {
	//
	//        for (Iterator it = getChildrenAndOptionalFacetsIterator(level, component); it.hasNext();)
	//        {
	//            UIComponent child = (UIComponent)it.next();
	//            //clear this descendant's clientId:
	//            child.setId(child.getId()); //HACK: This assumes that setId always clears the cached clientId. Can we be sure?
	//            if (child instanceof EditableValueHolder)
	//            {
	//                if (states != null)
	//                {
	//                    states[counter].restore((EditableValueHolder)child);
	//                }
	//                else if (initialStates != null)
	//                {
	//                    initialStates[counter].restore((EditableValueHolder)child);
	//                }
	//                else
	//                {
	//                    // No state saved yet and no initial state !?
	//                    // Should never be possible, but let's reset the component
	//                    // state to null values
	//                    ((EditableValueHolder)child).setValue(null);
	//                    ((EditableValueHolder)child).setLocalValueSet(false);
	//                    ((EditableValueHolder)child).setValid(true);
	//                    ((EditableValueHolder)child).setSubmittedValue(null);
	//                }
	//                counter++;
	//            }
	//            counter = restoreDescendantComponentStates(child, states, initialStates, counter, level+1);
	//        }
	//        return counter;
	//    }

	public void setRows(int rows)
	{
		_rows = new Integer(rows);
		if (rows < 0)
			throw new IllegalArgumentException("rows: " + rows);
	}

	public void setVar(String var)
	{
		_var = var;
	}

	public String getVar()
	{
		return _var;
	}

	public void setValueBinding(String name, ValueBinding binding)
	{
		if (name == null)
		{
			throw new NullPointerException("name");
		}
		else if (name.equals("value"))
		{
			_dataModel = null;
		}
		else if (name.equals("var") || name.equals("rowIndex"))
		{
			throw new IllegalArgumentException("name " + name);
		}
		super.setValueBinding(name, binding);
	}

	public String getClientId(FacesContext context)
	{
		String clientId = super.getClientId(context);
		int rowIndex = getRowIndex();
		if (rowIndex == -1)
		{
			return clientId;
		}
		else
		{
			return clientId + "_" + rowIndex;
		}
	}

	public void queueEvent(FacesEvent event)
	{
		super.queueEvent(new FacesEventWrapper(event, getRowIndex(), this));
	}

	public void broadcast(FacesEvent event) throws AbortProcessingException
	{
		if (event instanceof FacesEventWrapper)
		{
			FacesEvent originalEvent = ((FacesEventWrapper) event).getWrappedFacesEvent();
			int eventRowIndex = ((FacesEventWrapper) event).getRowIndex();
			int currentRowIndex = getRowIndex();
			setRowIndex(eventRowIndex);
			originalEvent.getComponent().broadcast(originalEvent);
			setRowIndex(currentRowIndex);
		}
		else
		{
			super.broadcast(event);
		}
	}

	public void encodeBegin(FacesContext context) throws IOException
	{
		if (_firstTimeRendered || isAllChildrenAndFacetsValid())
		{
			_saveDescendantStates = false; // no need to save children states
			//Refresh DataModel for rendering:
			_dataModel = null;
			if (_dataModelMap != null)
				_dataModelMap.clear();
		}
		else
		{
			_saveDescendantStates = true;
			// save children states (valid flag, submittedValues, etc.)
		}
		super.encodeBegin(context);
	}

	public void encodeEnd(FacesContext context) throws IOException
	{
		setRowIndex(-1);

		super.encodeEnd(context);
	}

    private boolean isAllChildrenAndFacetsValid()
    {
        int first = getFirst();
        int rows = getRows();
        int last;
        if (rows == 0)
        {
            last = getRowCount();
        }
        else
        {
            last = first + rows;
        }
        int setRowIndex = getRowIndex();
        try
        {
            for (int rowIndex = first; rowIndex < last; rowIndex++)
            {
                setRowIndex(rowIndex);
                if (isRowAvailable())
                {
                    if (!isAllEditableValueHoldersValidRecursive(getFacetsAndChildren()))
                    {
                        return false;
                    }
                }
            }
        }
        finally
        {
            setRowIndex(setRowIndex);
        }
        return true;
    }

	private boolean isAllEditableValueHoldersValidRecursive(Iterator facetsAndChildrenIterator)
	{
		while (facetsAndChildrenIterator.hasNext())
		{
			UIComponent c = (UIComponent) facetsAndChildrenIterator.next();
			if (c instanceof EditableValueHolder && !((EditableValueHolder) c).isValid())
			{
				return false;
			}
			if (!isAllEditableValueHoldersValidRecursive(c.getFacetsAndChildren()))
			{
				return false;
			}
		}
		return true;
	}

	public void processDecodes(FacesContext context)
	{
		if (context == null)
			throw new NullPointerException("context");
		if (!isRendered())
			return;
		setRowIndex(-1);
		processFacets(context, PROCESS_DECODES);
		processColumnFacets(context, PROCESS_DECODES);
		processColumnChildren(context, PROCESS_DECODES);
		setRowIndex(-1);
		try
		{
			decode(context);
		}
		catch (RuntimeException e)
		{
			context.renderResponse();
			throw e;
		}
	}

	public void processValidators(FacesContext context)
	{
		if (context == null)
			throw new NullPointerException("context");
		if (!isRendered())
			return;
		setRowIndex(-1);
		processFacets(context, PROCESS_VALIDATORS);
		processColumnFacets(context, PROCESS_VALIDATORS);
		processColumnChildren(context, PROCESS_VALIDATORS);
		setRowIndex(-1);
	}

	public void processUpdates(FacesContext context)
	{
		if (context == null)
			throw new NullPointerException("context");
		if (!isRendered())
			return;
		setRowIndex(-1);
		processFacets(context, PROCESS_UPDATES);
		processColumnFacets(context, PROCESS_UPDATES);
		processColumnChildren(context, PROCESS_UPDATES);
		setRowIndex(-1);
	}

	private void processFacets(FacesContext context, int processAction)
	{
		for (Iterator it = getFacets().values().iterator(); it.hasNext();)
		{
			UIComponent facet = (UIComponent) it.next();
			process(context, facet, processAction);
		}
	}

	private void processColumnFacets(FacesContext context, int processAction)
	{
		for (Iterator childIter = getChildren().iterator(); childIter.hasNext();)
		{
			UIComponent child = (UIComponent) childIter.next();
			if (child instanceof UIColumn)
			{
				if (!child.isRendered())
				{
					//Column is not visible
					continue;
				}
				for (Iterator facetsIter = child.getFacets().values().iterator();
					facetsIter.hasNext();
					)
				{
					UIComponent facet = (UIComponent) facetsIter.next();
					process(context, facet, processAction);
				}
			}
		}
	}

	private void processColumnChildren(FacesContext context, int processAction)
	{
		int first = getFirst();
		int rows = getRows();
		int last;
		if (rows == 0)
		{
			last = getRowCount();
		}
		else
		{
			last = first + rows;
		}
		for (int rowIndex = first; rowIndex < last; rowIndex++)
		{
			setRowIndex(rowIndex);
			if (isRowAvailable())
			{
				for (Iterator it = getChildren().iterator(); it.hasNext();)
				{
					UIComponent child = (UIComponent) it.next();
					if (child instanceof UIColumn)
					{
						if (!child.isRendered())
						{
							//Column is not visible
							continue;
						}
						for (Iterator columnChildIter = child.getChildren().iterator();
							columnChildIter.hasNext();
							)
						{
							UIComponent columnChild = (UIComponent) columnChildIter.next();
							process(context, columnChild, processAction);
						}