Examples of org.apache.myfaces.view.facelets.FaceletCompositionContext

Package org.apache.myfaces.view.facelets

Examples of org.apache.myfaces.view.facelets.FaceletCompositionContext

org.apache.myfaces.view.facelets.FaceletCompositionContext
@since 2.0.1 @author Leonardo Uribe (latest modification by $Author: lu4242 $) @version $Revision: 1195618 $ $Date: 2011-10-31 14:03:29 -0500 (Mon, 31 Oct 2011) $


    @Override
    public void apply(FaceletContext ctx, UIComponent parent) throws IOException
    {
        // we need methods from AbstractFaceletContext
        FaceletCompositionContext mctx = FaceletCompositionContext.getCurrentInstance(ctx);


        if (_wrapMode)
        {
            // the tag has children --> provide validator information for all children
            
            // FIXME the spec says we should save the validation groups in an attribute
            // on the parent UIComponent, but this will be a problem in the following scenario:
            // <h:form>
            //     <f:validateBean>
            //         <h:inputText />
            //     </f:validateBean>
            //     <h:inputText />
            // </h:form>
            // because the validator would also be applied to the second h:inputText,
            // which it should not, on my opinion. In addition, mojarra also does not
            // attach the validator to the second h:inputText in this scenario (blackbox test).
            // So I use the same way as f:ajax for this problem. -=Jakob Korherr=-
            
            String validatorId = _delegate.getValidatorConfig().getValidatorId();
            /*
            boolean disabled = _delegate.isDisabled(ctx);
            if (disabled)
            {
                // the validator is disabled --> add its id to the exclusion stack
                boolean validatorIdAvailable = validatorId != null && !"".equals(validatorId);
                try
                {
                    if (validatorIdAvailable)
                    {
                        mctx.pushExcludedValidatorIdToStack(validatorId);
                    }
                    _delegate.getValidatorConfig().getNextHandler().apply(ctx, parent);
                }
                finally
                {
                    if (validatorIdAvailable)
                    {
                        mctx.popExcludedValidatorIdToStack();
                    }
                }
            }
            else
            {*/
                // the validator is enabled 
                // --> add the validation groups and the validatorId to the stack
                //String groups = getValidationGroups(ctx);
                // spec: don't save the validation groups string if it is null or empty string
                //boolean groupsAvailable = groups != null 
                        //&& !groups.matches(BeanValidator.EMPTY_VALIDATION_GROUPS_PATTERN);
                //try
                //{
                    //if (groupsAvailable)
                    //{
                    //    mctx.pushValidationGroupsToStack(groups);
                    //}
                    try
                    {
                        mctx.pushEnclosingValidatorIdToStack(validatorId, this);
                        _delegate.getValidatorConfig().getNextHandler().apply(ctx, parent);
                    }
                    finally
                    {
                        mctx.popEnclosingValidatorIdToStack();
                    }
                //}
                //finally
                //{
                    //if (groupsAvailable)
                    //{
                        //mctx.popValidationGroupsToStack();
                    //}
                //}
            /*}*/
        }
        else
        {
            // Apply only if we are creating a new component
            if (!ComponentHandler.isNew(parent))
            {
                return;
            }


            // the tag is a leave --> attach validator to parent
            if (parent instanceof EditableValueHolder)
            {
                applyAttachedObject(ctx.getFacesContext(), parent);
            }
            else if (UIComponent.isCompositeComponent(parent))
            {
                if (getFor() == null)
                {
                    throw new TagException(_delegate.getTag(), "is nested inside a composite component"
                            + " but does not have a for attribute.");
                }
                mctx.addAttachedObjectHandler(parent, _delegate);
            }
            else
            {
                throw new TagException(_delegate.getTag(),
                        "Parent not composite component or an instance of EditableValueHolder: " + parent);

View Full Code Here

        {
            applyAttachedObject(ctx.getFacesContext(), parent);
        }
        else if (UIComponent.isCompositeComponent(parent))
        {
            FaceletCompositionContext mctx = FaceletCompositionContext.getCurrentInstance(ctx);
            mctx.addAttachedObjectHandler(parent, this);
        }
        else
        {
            throw new TagException(this.tag,
                    "Parent is not composite component or of type ActionSource, type is: " + parent);

View Full Code Here


        // our id
        String id = ctx.generateUniqueId(_delegate.getTagId());


        // Cast to use UniqueIdVendor stuff
        FaceletCompositionContext mctx = (FaceletCompositionContext) FaceletCompositionContext.getCurrentInstance(ctx);
                
        String componentId = mctx.generateUniqueComponentId();
            
        // grab our component
        UIComponent c = null;
        //boolean componentFoundInserted = false;


        //Used to preserve the original parent. Note when the view is being refreshed, the real parent could be
        //another component.
        UIComponent oldParent = parent;
        
        if (mctx.isRefreshingTransientBuild())
        {
            if (_relocatableResourceHandler != null)
            {
                c = _relocatableResourceHandler.findChildByTagId(ctx, parent, id);
            }
            else
            {
                c = ComponentSupport.findChildByTagId(parent, id); 
            }
        }
        boolean componentFound = false;
        if (c != null)
        {
            componentFound = true;
            // mark all children for cleaning
            if (log.isLoggable(Level.FINE))
            {
                log.fine(_delegate.getTag() + " Component[" + id + "] Found, marking children for cleanup");
            }
            mctx.markForDeletion(c);
        }
        else
        {
            c = this.createComponent(ctx);
            if (log.isLoggable(Level.FINE))
            {
                log.fine(_delegate.getTag() + " Component[" + id + "] Created: " + c.getClass().getName());
            }
            
            _delegate.setAttributes(ctx, c);


            // mark it owned by a facelet instance
            c.getAttributes().put(ComponentSupport.MARK_CREATED, id);


            if (facesContext.isProjectStage(ProjectStage.Development))
            {
                c.getAttributes().put(UIComponent.VIEW_LOCATION_KEY,
                        _delegate.getTag().getLocation());
            }


            // assign our unique id
            if (this._id != null)
            {
                c.setId(this._id.getValue(ctx));
            }
            else
            {
                UniqueIdVendor uniqueIdVendor = mctx.getUniqueIdVendorFromStack();
                if (uniqueIdVendor == null)
                {
                    uniqueIdVendor = facesContext.getViewRoot();
                    
                    if (uniqueIdVendor == null)
                    {
                        // facesContext.getViewRoot() returns null here if we are in
                        // phase restore view, so we have to try to get the view root
                        // via the method in ComponentSupport and our parent
                        uniqueIdVendor = ComponentSupport.getViewRoot(ctx, parent);
                    }
                }
                if (uniqueIdVendor != null)
                {
                    // UIViewRoot implements UniqueIdVendor, so there is no need to cast to UIViewRoot
                    // and call createUniqueId()
                    String uid = uniqueIdVendor.createUniqueId(facesContext, componentId);
                    c.setId(uid);
                }
            }


            if (this._rendererType != null)
            {
                c.setRendererType(this._rendererType);
            }


            // hook method
            _delegate.onComponentCreated(ctx, c, parent);
        }
        c.pushComponentToEL(facesContext, c);


        if (c instanceof UniqueIdVendor)
        {
            mctx.pushUniqueIdVendorToStack((UniqueIdVendor)c);
        }
        // first allow c to get populated
        _delegate.applyNextHandler(ctx, c);


        boolean oldProcessingEvents = facesContext.isProcessingEvents();
        // finish cleaning up orphaned children
        if (componentFound)
        {
            mctx.finalizeForDeletion(c);


            //if (!componentFoundInserted)
            //{
                if (mctx.isRefreshingTransientBuild())
                {
                    facesContext.setProcessingEvents(false);
                    if (_relocatableResourceHandler != null &&
                        parent != null && !parent.equals(c.getParent()))
                    {
                        // Replace parent with the relocated parent.
                        parent = c.getParent();
                    }
                }
                if (facetName == null)
                {
                    parent.getChildren().remove(c);
                }
                else
                {
                    ComponentSupport.removeFacet(ctx, parent, c, facetName);
                }
                if (mctx.isRefreshingTransientBuild())
                {
                    facesContext.setProcessingEvents(oldProcessingEvents);
                }
            //}
        }




        if (!componentFound)
        {
            if (c instanceof ClientBehaviorHolder && !UIComponent.isCompositeComponent(c))
            {
                Iterator<AjaxHandler> it = ((AbstractFaceletContext) ctx).getAjaxHandlers();
                if (it != null)
                {
                    while(it.hasNext())
                    {
                        it.next().applyAttachedObject(facesContext, c);
                    }
                }
            }
            
            if (c instanceof EditableValueHolder)
            {
                // add default validators here, because this feature 
                // is only available in facelets (see MYFACES-2362 for details)
                addEnclosingAndDefaultValidators(ctx, mctx, facesContext, (EditableValueHolder) c);
            }
        }
        
        _delegate.onComponentPopulated(ctx, c, oldParent);


        if (componentFound && mctx.isRefreshingTransientBuild())
        {
            facesContext.setProcessingEvents(false);
        }
        if (facetName == null)
        {
            parent.getChildren().add(c);
        }
        else
        {
            ComponentSupport.addFacet(ctx, parent, c, facetName);
        }
        if (componentFound && mctx.isRefreshingTransientBuild())
        {
            facesContext.setProcessingEvents(oldProcessingEvents);
        }


        if (c instanceof UniqueIdVendor)
        {
            mctx.popUniqueIdVendorToStack();
        }


        c.popComponentFromEL(facesContext);
        
        if (mctx.isMarkInitialState())
        {
            //Call it only if we are using partial state saving
            c.markInitialState();
        }
    }

View Full Code Here

     *      javax.faces.component.UIComponent)
     */
    public void apply(FacesContext facesContext, UIComponent parent) throws IOException, FacesException,
            FaceletException, ELException
    {
        FaceletCompositionContext myFaceletContext = null;
        boolean faceletCompositionContextInitialized = false;
        myFaceletContext = FaceletCompositionContext.getCurrentInstance(facesContext);
        if (myFaceletContext == null)
        {
            myFaceletContext = new FaceletCompositionContextImpl(_factory, facesContext);
            myFaceletContext.init(facesContext);
            faceletCompositionContextInitialized = true;
        }
        DefaultFaceletContext ctx = new DefaultFaceletContext(facesContext, this, myFaceletContext);
        
        //Set FACELET_CONTEXT_KEY on FacesContext attribute map, to 
        //reflect the current facelet context instance
        facesContext.getAttributes().put(FaceletContext.FACELET_CONTEXT_KEY, ctx);
        
        ctx.pushPageContext(new PageContextImpl());
        
        try
        {
            // push the parent as a UniqueIdVendor to the stack here,
            // if there is no UniqueIdVendor on the stack yet
            boolean pushedUniqueIdVendor = false;
            if (parent instanceof UniqueIdVendor
                && ctx.getFaceletCompositionContext().getUniqueIdVendorFromStack() == null)
            {
                ctx.getFaceletCompositionContext().pushUniqueIdVendorToStack((UniqueIdVendor) parent);
                pushedUniqueIdVendor = true;
            }
            
            this.refresh(parent);
            myFaceletContext.markForDeletion(parent);
            _root.apply(ctx, parent);
            myFaceletContext.finalizeForDeletion(parent);
            this.markApplied(parent);
            
            // remove the UniqueIdVendor from the stack again
            if (pushedUniqueIdVendor)
            {
                ctx.getFaceletCompositionContext().popUniqueIdVendorToStack();
            }
        }
        finally
        {
            ctx.popPageContext();
            
            if (faceletCompositionContextInitialized)
            {
                myFaceletContext.release(facesContext);
            }
        }
    }

View Full Code Here

        try
        {
            // push the parent as a UniqueIdVendor to the stack here,
            // if there is no UniqueIdVendor on the stack yet
            boolean pushedUniqueIdVendor = false;
            FaceletCompositionContext mctx = ctx.getFaceletCompositionContext();
            if (parent instanceof UniqueIdVendor
                && ctx.getFaceletCompositionContext().getUniqueIdVendorFromStack() == null)
            {
                mctx.pushUniqueIdVendorToStack((UniqueIdVendor) parent);
                pushedUniqueIdVendor = true;
            }
            
            this.refresh(parent);
            mctx.markForDeletion(parent);
            DefaultFaceletContext ctxWrapper = new DefaultFaceletContext( (DefaultFaceletContext)ctx, f, true);
            //Update FACELET_CONTEXT_KEY on FacesContext attribute map, to 
            //reflect the current facelet context instance
            ctx.getFacesContext().getAttributes().put(FaceletContext.FACELET_CONTEXT_KEY, ctxWrapper);
            f._root.apply(ctxWrapper, parent);
            ctx.getFacesContext().getAttributes().put(FaceletContext.FACELET_CONTEXT_KEY, ctx);
            mctx.finalizeForDeletion(parent);
            this.markApplied(parent);
            
            // remove the UniqueIdVendor from the stack again
            if (pushedUniqueIdVendor)
            {

View Full Code Here

            // our id
            String id = ctx.generateUniqueId(this.id);


            // grab our component
            UIComponent c = null;
            FaceletCompositionContext mctx= FaceletCompositionContext.getCurrentInstance(ctx);
            boolean componentFoundInserted = false;
            
            String componentId = mctx.generateUniqueComponentId();
            
            if (mctx.isRefreshingTransientBuild())
            {
                c = ComponentSupport.findChildByTagId(parent, id);
            }
            boolean componentFound = false;
            if (c != null)
            {
                componentFound = true;
                // mark all children for cleaning
                mctx.markForDeletion(c);
            }
            else
            {
                Instruction[] applied;
                if (this.literal)
                {
                    applied = this.instructions;
                }
                else
                {
                    int size = this.instructions.length;
                    applied = new Instruction[size];
                    // Create a new list with all of the necessary applied
                    // instructions
                    Instruction ins;
                    for (int i = 0; i < size; i++)
                    {
                        ins = this.instructions[i];
                        applied[i] = ins.apply(ctx.getExpressionFactory(), ctx);
                    }
                }


                c = new UIInstructions(txt, applied);
                // mark it owned by a facelet instance
                //c.setId(ComponentSupport.getViewRoot(ctx, parent).createUniqueId());


                UniqueIdVendor uniqueIdVendor
                        = FaceletCompositionContext.getCurrentInstance(ctx).getUniqueIdVendorFromStack();
                if (uniqueIdVendor == null)
                {
                    uniqueIdVendor = ComponentSupport.getViewRoot(ctx, parent);
                }
                if (uniqueIdVendor != null)
                {
                    // UIViewRoot implements UniqueIdVendor, so there is no need to cast to UIViewRoot
                    // and call createUniqueId(). Also, note that UIViewRoot.createUniqueId() javadoc
                    // says we could send as seed the facelet generated id.
                    String uid = uniqueIdVendor.createUniqueId(ctx.getFacesContext(), componentId);
                    c.setId(uid);
                }                
                c.getAttributes().put(ComponentSupport.MARK_CREATED, id);
            }
            
            boolean oldProcessingEvents = ctx.getFacesContext().isProcessingEvents();
            // finish cleaning up orphaned children
            if (componentFound)
            {
                mctx.finalizeForDeletion(c);
                if (!componentFoundInserted)
                {
                    if (mctx.isRefreshingTransientBuild())
                    {
                        ctx.getFacesContext().setProcessingEvents(false); 
                    }
                    parent.getChildren().remove(c);
                    if (mctx.isRefreshingTransientBuild())
                    {
                        ctx.getFacesContext().setProcessingEvents(oldProcessingEvents);
                    }
                }
            }
            if (!componentFoundInserted)
            {
                if (componentFound && mctx.isRefreshingTransientBuild())
                {
                    ctx.getFacesContext().setProcessingEvents(false); 
                }
                this.addComponent(ctx, parent, c);
                if (componentFound && mctx.isRefreshingTransientBuild())
                {
                    ctx.getFacesContext().setProcessingEvents(oldProcessingEvents);
                }
            }
        }

View Full Code Here

    }


    public void apply(FaceletContext ctx, UIComponent parent)
            throws IOException
    {
        FaceletCompositionContext mctx = FaceletCompositionContext.getCurrentInstance(ctx);
        AbstractFaceletContext actx = (AbstractFaceletContext)ctx;
        UIComponent compositeBaseParent = actx.isBuildingCompositeComponentMetadata() ? parent : parent.getParent();
        
        // Store the current Location on the parent (the location is needed
        // to resolve the related composite component via #{cc} properly).
        if (_interfaceHandler != null)
        {
            compositeBaseParent.getAttributes()
                .put(CompositeComponentELUtils.LOCATION_KEY, this._interfaceHandler.getLocation());
        }
        else if (_implementationHandler != null)
        {
            compositeBaseParent.getAttributes()
                .put(CompositeComponentELUtils.LOCATION_KEY, this._implementationHandler.getLocation());
        }
        
        // Only apply if we are building composite component metadata,
        // in other words we are calling ViewDeclarationLanguage.getComponentMetadata
        if ( actx.isBuildingCompositeComponentMetadata() )
        {
            CompositeComponentBeanInfo tempBeanInfo = 
                (CompositeComponentBeanInfo) compositeBaseParent.getAttributes()
                .get(UIComponent.BEANINFO_KEY);
            
            if (tempBeanInfo == null)
            {
                if (_cacheable)
                {
                    if (_cachedBeanInfo == null)
                    {
                        _cachedBeanInfo = _createCompositeComponentMetadata(ctx, compositeBaseParent);
                        compositeBaseParent.getAttributes().put(
                                UIComponent.BEANINFO_KEY, _cachedBeanInfo);
                        
                        try
                        {
                            mctx.pushCompositeComponentToStack(compositeBaseParent);


                            _nextHandler.apply(ctx, parent);
                            
                            Collection<String> declaredDefaultValues = null;
                            
                            for (PropertyDescriptor pd : _cachedBeanInfo.getPropertyDescriptors())
                            {
                                if (pd.getValue("default") != null)
                                {
                                    if (declaredDefaultValues  == null)
                                    {
                                        declaredDefaultValues = new ArrayList<String>();
                                    }
                                    declaredDefaultValues.add(pd.getName());
                                }
                            }
                            if (declaredDefaultValues == null)
                            {
                                declaredDefaultValues = Collections.emptyList();
                            }
                            _cachedBeanInfo.getBeanDescriptor().
                                    setValue(UIComponent.ATTRS_WITH_DECLARED_DEFAULT_VALUES, declaredDefaultValues);
                        }
                        finally
                        {
                            mctx.popCompositeComponentToStack();
                        }
                    }
                    else
                    {
                        // Put the cached instance, but in that case it is not necessary to call
                        // nextHandler
                        compositeBaseParent.getAttributes().put(
                                UIComponent.BEANINFO_KEY, _cachedBeanInfo);
                    }
                }
                else
                {
                    tempBeanInfo = _createCompositeComponentMetadata(ctx, compositeBaseParent);
                    compositeBaseParent.getAttributes().put(
                            UIComponent.BEANINFO_KEY, tempBeanInfo);
                    
                    try
                    {
                        mctx.pushCompositeComponentToStack(compositeBaseParent);
                    
                        _nextHandler.apply(ctx, parent);
                        
                        Collection<String> declaredDefaultValues = null;
                        
                        for (PropertyDescriptor pd : tempBeanInfo.getPropertyDescriptors())
                        {
                            if (pd.getValue("default") != null)
                            {
                                if (declaredDefaultValues  == null)
                                {
                                    declaredDefaultValues = new ArrayList<String>();
                                }
                                declaredDefaultValues.add(pd.getName());
                            }
                        }
                        if (declaredDefaultValues == null)
                        {
                            declaredDefaultValues = Collections.emptyList();
                        }
                        tempBeanInfo.getBeanDescriptor().
                                setValue(UIComponent.ATTRS_WITH_DECLARED_DEFAULT_VALUES, declaredDefaultValues);
                    }
                    finally
                    {
                        mctx.popCompositeComponentToStack();
                    }
                }
            }
        }
        else
        {
            try
            {
                mctx.pushCompositeComponentToStack(compositeBaseParent);
            
                _nextHandler.apply(ctx, parent);
            }
            finally
            {
                mctx.popCompositeComponentToStack();
            }
        }
    }

View Full Code Here

    }


    public void apply(FaceletContext ctx, UIComponent parent) throws IOException, FacesException, FaceletException,
            ELException
    {
        FaceletCompositionContext fcc = FaceletCompositionContext.getCurrentInstance(ctx);
        boolean processed = false;
        //assign an unique id for this section
        String uniqueId = fcc.startComponentUniqueIdSection();
        Integer savedOption = getSavedOption(ctx, fcc, parent, uniqueId);
        for (int i = 0; i < this.when.length; i++)
        {
            //Ensure each option has its unique section
            fcc.startComponentUniqueIdSection();
            if (!processed)
            {
                if ((savedOption != null) ? savedOption.equals(i) : this.when[i].isTestTrue(ctx))
                {
                    this.when[i].apply(ctx, parent);
                    processed = true;
                    savedOption = i;
                    //return;
                }
            }
            fcc.endComponentUniqueIdSection();
        }
        if (this.otherwise != null)
        {
            fcc.startComponentUniqueIdSection();
            if (!processed)
            {
                this.otherwise.apply(ctx, parent);
                savedOption = -1;
            }
            fcc.endComponentUniqueIdSection();
        }
        
        fcc.endComponentUniqueIdSection();


        ComponentSupport.saveInitialTagState(ctx, fcc, parent, uniqueId, savedOption);
        if (fcc.isUsingPSSOnThisView() && fcc.isRefreshTransientBuildOnPSS() && !fcc.isRefreshingTransientBuild())
        {
            //Mark the parent component to be saved and restored fully.
            ComponentSupport.markComponentToRestoreFully(ctx.getFacesContext(), parent);
        }
    }

View Full Code Here

            {
                b[i] = (byte) i;
            }
            src = b;
        }
        FaceletCompositionContext fcc = FaceletCompositionContext.getCurrentInstance(ctx);
        if (src != null)
        {
            fcc.startComponentUniqueIdSection();
            Iterator<?> itr = this.toIterator(src);
            if (itr != null)
            {
                int i = 0;


                // move to start
                while (i < s && itr.hasNext())
                {
                    itr.next();
                    i++;
                }


                String v = this.getVarName(ctx);
                String vs = this.getVarStatusName(ctx);
                VariableMapper vars = ctx.getVariableMapper();
                ValueExpression ve = null;
                ValueExpression vO = this.capture(v, vars);
                ValueExpression vsO = this.capture(vs, vars);
                int mi = 0;
                Object value = null;
                try
                {
                    boolean first = true;
                    while (i <= e && itr.hasNext())
                    {
                        value = itr.next();


                        // set the var
                        if (v != null)
                        {
                            if (t || srcVE == null)
                            {
                                ctx.setAttribute(v, value);
                            }
                            else
                            {
                                ve = this.getVarExpr(srcVE, src, value, i);
                                vars.setVariable(v, ve);
                            }
                        }


                        // set the varStatus
                        if (vs != null)
                        {
                            IterationStatus itrS = new IterationStatus(first, !itr.hasNext(), i, sO, eO, mO, value);
                            if (t || srcVE == null)
                            {
                                ctx.setAttribute(vs, itrS);
                            }
                            else
                            {
                                ve = new IterationStatusExpression(itrS);
                                vars.setVariable(vs, ve);
                            }
                        }


                        // execute body
                        this.nextHandler.apply(ctx, parent);


                        // increment steps
                        mi = 1;
                        while (mi < m && itr.hasNext())
                        {
                            itr.next();
                            mi++;
                            i++;
                        }
                        i++;


                        first = false;
                    }
                }
                finally
                {
                    if (v != null)
                    {
                        vars.setVariable(v, vO);
                    }
                    if (vs != null)
                    {
                        vars.setVariable(vs, vsO);
                    }
                }
            }
            fcc.endComponentUniqueIdSection();
        }


        if (fcc.isUsingPSSOnThisView() && fcc.isRefreshTransientBuildOnPSS() && !fcc.isRefreshingTransientBuild())
        {
            //Mark the parent component to be saved and restored fully.
            ComponentSupport.markComponentToRestoreFully(ctx.getFacesContext(), parent);
        }
    }

View Full Code Here

        this.var = this.getAttribute("var");
    }


    public void apply(FaceletContext ctx, UIComponent parent) throws IOException, FacesException, ELException
    {
        FaceletCompositionContext fcc = FaceletCompositionContext.getCurrentInstance(ctx);
        String uniqueId = fcc.startComponentUniqueIdSection();
        boolean b = getTestValue(ctx, fcc, parent, uniqueId);
        if (this.var != null)
        {
            ctx.setAttribute(var.getValue(ctx), new Boolean(b));
        }
        if (b)
        {
            this.nextHandler.apply(ctx, parent);
        }
        fcc.endComponentUniqueIdSection();
        //AbstractFaceletContext actx = (AbstractFaceletContext) ctx;
        ComponentSupport.saveInitialTagState(ctx, fcc, parent, uniqueId, b);
        if (fcc.isUsingPSSOnThisView() && fcc.isRefreshTransientBuildOnPSS() && !fcc.isRefreshingTransientBuild())
        {
            //Mark the parent component to be saved and restored fully.
            ComponentSupport.markComponentToRestoreFully(ctx.getFacesContext(), parent);
        }
    }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.apache.myfaces.view.facelets.FaceletCompositionContext

org.apache.myfaces.application.ApplicationImpl

org.apache.myfaces.view.facelets.compiler.DynamicComponentFacelet

org.apache.myfaces.view.facelets.compiler.UIInstructionHandler

org.apache.myfaces.view.facelets.impl.DefaultFacelet

org.apache.myfaces.view.facelets.tag.composite.CompositeComponentDefinitionTagHandler

org.apache.myfaces.view.facelets.tag.composite.CompositeComponentResourceTagHandler

org.apache.myfaces.view.facelets.tag.composite.CreateDynamicCompositeComponentListener

org.apache.myfaces.view.facelets.tag.jsf.BehaviorTagHandlerDelegate

org.apache.myfaces.view.facelets.tag.jsf.ComponentSupport

org.apache.myfaces.view.facelets.tag.jsf.ComponentTagHandlerDelegate

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.