The standard component type for this component.

The standard component family for this component.

The prefix that will be used for identifiers generated by the createUniqueId() method. 

 public UIViewRoot() 
{
    // ------------------------------------------------------------ Constructors
        super();
        setRendererType(null);
}

Create a new UIViewRoot instance with default property values.

 public  void addPhaseListener(PhaseListener newPhaseListener) 
{
        if (null == phaseListeners) {
            //noinspection CollectionWithoutInitialCapacity
            phaseListeners = new ArrayList< PhaseListener >();
        }
        phaseListeners.add(newPhaseListener);
}

 public String createUniqueId() 
{
        return UNIQUE_ID_PREFIX + lastId++;
}

Generate an identifier for a component. The identifier will be prefixed with UNIQUE_ID_PREFIX, and will be unique within this UIViewRoot.

 public  void encodeBegin(FacesContext context) throws IOException 
{
        initState();
        notifyBefore(context, PhaseId.RENDER_RESPONSE);
        if (!skipPhase) {
            super.encodeBegin(context);
        }
}

Override the default UIComponentBase#encodeBegin behavior. If #getBeforePhaseListener returns non-null, invoke it, passing a PhaseEvent for the PhaseId#RENDER_RESPONSE phase. If the internal list populated by calls to #addPhaseListener is non-empty, any listeners in that list must have their PhaseListener#beforePhase method called, passing the PhaseEvent. Any errors that occur during invocation of any of the the beforePhase listeners must be logged and swallowed. After listeners are invoked call superclass processing.

 public  void encodeEnd(FacesContext context) throws IOException 
{
        super.encodeEnd(context);
        notifyAfter(context, PhaseId.RENDER_RESPONSE);
}

Override the default UIComponentBase#encodeEnd behavior. If #getAfterPhaseListener returns non-null, invoke it, passing a PhaseEvent for the PhaseId#RENDER_RESPONSE phase. Any errors that occur during invocation of the afterPhase listener must be logged and swallowed.

 public MethodExpression getAfterPhaseListener() 
{
        return afterPhase;
}

 public MethodExpression getBeforePhaseListener() 
{
                              
        return beforePhase;
}

 public String getFamily() 
{
    // -------------------------------------------------------------- Properties
        return (COMPONENT_FAMILY);
}

 public Locale getLocale() 
{
                                                                                                                       
        Locale result = null;
        if (null != locale) {
            result = this.locale;
        } else {
            ValueExpression vb = getValueExpression("locale");
            FacesContext context = getFacesContext();
            if (vb != null) {
                Object resultLocale = null;
                try {
                    resultLocale = vb.getValue(context.getELContext());
                }
                catch (ELException e) {
                    if (LOGGER.isLoggable(Level.SEVERE)) {
                        LOGGER.log(Level.SEVERE,
                                   "severe.component.unable_to_process_expression",
                                   new Object[]{vb.getExpressionString(), "locale"});
                    }
                }
                if (null == resultLocale) {
                    result =
                          context.getApplication().getViewHandler()
                                .calculateLocale(context);
                } else if (resultLocale instanceof Locale) {
                    result = (Locale) resultLocale;
                } else if (resultLocale instanceof String) {
                    result = getLocaleFromString((String) resultLocale);
                }
            } else {
                result =
                      context.getApplication().getViewHandler()
                            .calculateLocale(context);
            }
        }
        return result;
}

Return the Locale to be used in localizing the response being created for this view.

Algorithm:

If we have a locale ivar, return it. If we have a value expression for "locale", get its value. If the value is null, return the result of calling javax.faces.application.ViewHandler#calculateLocale . If the value is an instance of java.util.Locale return it. If the value is a String, convert it to a java.util.Locale and return it. If there is no value expression for "locale", return the result of calling javax.faces.application.ViewHandler#calculateLocale .

 public String getRenderKitId() 
{
                                    
        String result;
        if (null != renderKitId) {
            result = this.renderKitId;
        } else {
            ValueExpression vb = getValueExpression("renderKitId");
            FacesContext context = getFacesContext();
            if (vb != null) {
                try {
                    result = (String) vb.getValue(context.getELContext());
                }
                catch (ELException e) {
                    if (LOGGER.isLoggable(Level.SEVERE)) {
                        LOGGER.log(Level.SEVERE,
                                   "severe.component.unable_to_process_expression",
                                   new Object[] { vb.getExpressionString(), "renderKitId"});
                    }
                    result = null;
                }
            } else {
                result = null;
            }
        }
        return result;
}

Return the render kit identifier of the RenderKit associated with this view. Unless explicitly set, as in javax.faces.application.ViewHandler#createView , the returned value will be null.

 public String getViewId() 
{
            
        return (this.viewId);
}

Return the view identifier for this view.

 public  void processApplication(FacesContext context) 
{
        initState();
        notifyBefore(context, PhaseId.INVOKE_APPLICATION);
        try {
            if (!skipPhase) {
                // NOTE - no tree walk is performed; this is a UIViewRoot-only operation
                broadcastEvents(context, PhaseId.INVOKE_APPLICATION);
            }
        } finally {
            clearFacesEvents(context);
            notifyAfter(context, PhaseId.INVOKE_APPLICATION);
        }
}

Broadcast any events that have been queued for the Invoke Application phase of the request processing lifecycle and to clear out any events for later phases if the event processing for this phase caused FacesContext#renderResponse or FacesContext#responseComplete to be called.

 public  void processDecodes(FacesContext context) 
{
        initState();
        notifyBefore(context, PhaseId.APPLY_REQUEST_VALUES);
        if (!skipPhase) {
            super.processDecodes(context);
            broadcastEvents(context, PhaseId.APPLY_REQUEST_VALUES);
        }
        clearFacesEvents(context);
        notifyAfter(context, PhaseId.APPLY_REQUEST_VALUES);
}

Override the default UIComponentBase#processDecodes behavior to broadcast any queued events after the default processing has been completed and to clear out any events for later phases if the event processing for this phase caused FacesContext#renderResponse or FacesContext#responseComplete to be called.

 public  void processUpdates(FacesContext context) 
{
        initState();
        notifyBefore(context, PhaseId.UPDATE_MODEL_VALUES);
        try {
            if (!skipPhase) {
                super.processUpdates(context);
                broadcastEvents(context, PhaseId.UPDATE_MODEL_VALUES);
            }
        } finally {
            clearFacesEvents(context);
            notifyAfter(context, PhaseId.UPDATE_MODEL_VALUES);
        }
}

Override the default UIComponentBase behavior to broadcast any queued events after the default processing has been completed and to clear out any events for later phases if the event processing for this phase caused FacesContext#renderResponse or FacesContext#responseComplete to be called.

 public  void processValidators(FacesContext context) 
{
        initState();
        notifyBefore(context, PhaseId.PROCESS_VALIDATIONS);
        try {
            if (!skipPhase) {
                super.processValidators(context);
                broadcastEvents(context, PhaseId.PROCESS_VALIDATIONS);
            }
        } finally {
            clearFacesEvents(context);
            notifyAfter(context, PhaseId.PROCESS_VALIDATIONS);
        }
}

Override the default UIComponentBase#processValidators behavior to broadcast any queued events after the default processing has been completed and to clear out any events for later phases if the event processing for this phase caused FacesContext#renderResponse or FacesContext#responseComplete to be called.

 public  void queueEvent(FacesEvent event) 
{
                                                                                                              
        if (event == null) {
            throw new NullPointerException();
        }
        int i;
        int len = PhaseId.VALUES.size();
        // We are a UIViewRoot, so no need to check for the ISE
        if (events == null) {
            List< List< FacesEvent > > events = new ArrayList< List< FacesEvent > >(len);
            for (i = 0; i <  len; i++) {
                events.add(new ArrayList< FacesEvent >(5));
            }
            this.events = events;
        }
        events.get(event.getPhaseId().getOrdinal()).add(event);
}

Override the default UIComponentBase#queueEvent behavior to accumulate the queued events for later broadcasting.

 public  void removePhaseListener(PhaseListener toRemove) 
{
        
        if (null != phaseListeners) {
            phaseListeners.remove(toRemove);
        }
}

 public  void restoreState(FacesContext context,
    Object state) 
{
        values = (Object[]) state;
        super.restoreState(context, values[0]);
        renderKitId = (String) values[1];
        viewId = (String) values[2];
        locale = (Locale) values[3];
        lastId = ((Integer) values[4]).intValue();
        beforePhase =
              (MethodExpression) restoreAttachedState(context, values[5]);
        afterPhase =
              (MethodExpression) restoreAttachedState(context, values[6]);
        phaseListeners = TypedCollections.dynamicallyCastList((List)
              restoreAttachedState(context, values[7]), PhaseListener.class);
}

 public Object saveState(FacesContext context) 
{
        if (values == null) {
            values = new Object[8];
        }
        values[0] = super.saveState(context);
        values[1] = renderKitId;
        values[2] = viewId;
        values[3] = locale;
        values[4] = lastId;
        values[5] = saveAttachedState(context, beforePhase);
        values[6] = saveAttachedState(context, afterPhase);
        values[7] = saveAttachedState(context, phaseListeners);
        return (values);
}

 public  void setAfterPhaseListener(MethodExpression newAfterPhase) 
{
        afterPhase = newAfterPhase;
}

Allow an arbitrary method to be called for the "afterPhase" event as the UIViewRoot runs through its lifecycle. This method will be called for all phases except PhaseId#RESTORE_VIEW . Unlike a true PhaseListener , this approach doesn't allow for only receiving PhaseEvent s for a given phase.

The method must conform to the signature of PhaseListener#afterPhase .

 public  void setBeforePhaseListener(MethodExpression newBeforePhase) 
{
        beforePhase = newBeforePhase;
}

Allow an arbitrary method to be called for the "beforePhase" event as the UIViewRoot runs through its lifecycle. This method will be called for all phases except PhaseId#RESTORE_VIEW . Unlike a true PhaseListener , this approach doesn't allow for only receiving PhaseEvent s for a given phase.

The method must conform to the signature of PhaseListener#beforePhase .

 public  void setLocale(Locale locale) 
{
        this.locale = locale;
        // Make sure to appraise the EL of this switch in Locale.
        FacesContext.getCurrentInstance().getELContext().setLocale(locale);
}

Set the Locale to be used in localizing the response being created for this view.

 public  void setRenderKitId(String renderKitId) 
{
        this.renderKitId = renderKitId;
}

Set the render kit identifier of the RenderKit associated with this view. This method may be called at any time between the end of Apply Request Values phase of the request processing lifecycle (i.e. when events are being broadcast) and the beginning of the Render Response phase.

 public  void setViewId(String viewId) 
{
        this.viewId = viewId;
}

Set the view identifier for this view.