/*

  * Licensed to the Apache Software Foundation (ASF) under one

  * or more contributor license agreements.  See the NOTICE file

  * distributed with this work for additional information

  * regarding copyright ownership.  The ASF licenses this file

  * to you under the Apache License, Version 2.0 (the

  * "License"); you may not use this file except in compliance

  * with the License.  You may obtain a copy of the License at

  *

  *   http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing,

  * software distributed under the License is distributed on an

  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

  * KIND, either express or implied.  See the License for the

  * specific language governing permissions and limitations

  * under the License.

  */

 package org.apache.myfaces.view.facelets;

 import java.beans.BeanDescriptor;

 import java.beans.BeanInfo;

 import java.beans.PropertyDescriptor;

 import java.io.FileNotFoundException;

 import java.io.IOException;

 import java.io.Writer;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.EnumSet;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import javax.el.ELContext;

 import javax.el.ELException;

 import javax.el.MethodExpression;

 import javax.el.ValueExpression;

 import javax.el.VariableMapper;

 import javax.faces.FacesException;

 import javax.faces.FacesWrapper;

 import javax.faces.FactoryFinder;

 import javax.faces.application.Application;

 import javax.faces.application.ProjectStage;

 import javax.faces.application.Resource;

 import javax.faces.application.StateManager;

 import javax.faces.application.ViewHandler;

 import javax.faces.component.ActionSource2;

 import javax.faces.component.EditableValueHolder;

 import javax.faces.component.UIComponent;

 import javax.faces.component.UINamingContainer;

 import javax.faces.component.UIPanel;

 import javax.faces.component.UIViewRoot;

 import javax.faces.component.visit.VisitContext;

 import javax.faces.component.visit.VisitHint;

 import javax.faces.context.ExternalContext;

 import javax.faces.context.FacesContext;

 import javax.faces.context.ResponseWriter;

 import javax.faces.event.ActionEvent;

 import javax.faces.event.ActionListener;

 import javax.faces.event.MethodExpressionActionListener;

 import javax.faces.event.MethodExpressionValueChangeListener;

 import javax.faces.event.PhaseId;

 import javax.faces.event.PostAddToViewEvent;

 import javax.faces.event.PostRestoreStateEvent;

 import javax.faces.event.ValueChangeEvent;

 import javax.faces.event.ValueChangeListener;

 import javax.faces.render.RenderKit;

 import javax.faces.render.RenderKitFactory;

 import javax.faces.render.ResponseStateManager;

 import javax.faces.validator.MethodExpressionValidator;

 import javax.faces.validator.Validator;

 import javax.faces.view.ActionSource2AttachedObjectHandler;

 import javax.faces.view.ActionSource2AttachedObjectTarget;

 import javax.faces.view.AttachedObjectHandler;

 import javax.faces.view.AttachedObjectTarget;

 import javax.faces.view.BehaviorHolderAttachedObjectHandler;

 import javax.faces.view.BehaviorHolderAttachedObjectTarget;

 import javax.faces.view.EditableValueHolderAttachedObjectHandler;

 import javax.faces.view.EditableValueHolderAttachedObjectTarget;

 import javax.faces.view.StateManagementStrategy;

 import javax.faces.view.ValueHolderAttachedObjectHandler;

 import javax.faces.view.ValueHolderAttachedObjectTarget;

 import javax.faces.view.ViewDeclarationLanguage;

 import javax.faces.view.ViewMetadata;

 import javax.faces.view.facelets.Facelet;

 import javax.faces.view.facelets.FaceletContext;

 import javax.faces.view.facelets.ResourceResolver;

 import javax.servlet.http.HttpServletResponse;

 import org.apache.myfaces.application.StateManagerImpl;

 import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFWebConfigParam;

 import org.apache.myfaces.config.RuntimeConfig;

 import org.apache.myfaces.shared.application.DefaultViewHandlerSupport;

 import org.apache.myfaces.shared.application.ViewHandlerSupport;

 import org.apache.myfaces.shared.config.MyfacesConfig;

 import org.apache.myfaces.shared.util.ClassUtils;

 import org.apache.myfaces.shared.util.StringUtils;

 import org.apache.myfaces.shared.util.WebConfigParamUtils;

 import org.apache.myfaces.view.ViewDeclarationLanguageStrategy;

 import org.apache.myfaces.view.ViewMetadataBase;

 import org.apache.myfaces.view.facelets.compiler.Compiler;

 import org.apache.myfaces.view.facelets.compiler.SAXCompiler;

 import org.apache.myfaces.view.facelets.el.CompositeComponentELUtils;

 import org.apache.myfaces.view.facelets.el.LocationMethodExpression;

 import org.apache.myfaces.view.facelets.el.LocationValueExpression;

 import org.apache.myfaces.view.facelets.el.MethodExpressionMethodExpression;

 import org.apache.myfaces.view.facelets.el.RedirectMethodExpressionValueExpressionActionListener;

 import org.apache.myfaces.view.facelets.el.RedirectMethodExpressionValueExpressionValidator;

 import org.apache.myfaces.view.facelets.el.RedirectMethodExpressionValueExpressionValueChangeListener;

 import org.apache.myfaces.view.facelets.el.ValueExpressionMethodExpression;

 import org.apache.myfaces.view.facelets.el.VariableMapperWrapper;

 import org.apache.myfaces.view.facelets.impl.DefaultFaceletFactory;

 import org.apache.myfaces.view.facelets.impl.DefaultResourceResolver;

 import org.apache.myfaces.view.facelets.tag.composite.ClientBehaviorAttachedObjectTarget;

 import org.apache.myfaces.view.facelets.tag.composite.ClientBehaviorRedirectBehaviorAttachedObjectHandlerWrapper;

 import org.apache.myfaces.view.facelets.tag.composite.ClientBehaviorRedirectEventComponentWrapper;

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

 import org.apache.myfaces.view.facelets.tag.jsf.core.AjaxHandler;

 import org.apache.myfaces.view.facelets.tag.ui.UIDebug;

 import static org.apache.myfaces.view.facelets.DefaultFaceletsStateManagementStrategy.*;

 import org.apache.myfaces.view.facelets.compiler.FaceletsCompilerSupport;

 import org.apache.myfaces.view.facelets.compiler.RefreshDynamicComponentListener;

 import org.apache.myfaces.view.facelets.impl.SectionUniqueIdCounter;

 import org.apache.myfaces.view.facelets.pool.RestoreViewFromPoolResult;

 import org.apache.myfaces.view.facelets.pool.ViewEntry;

 import org.apache.myfaces.view.facelets.pool.ViewPool;

 import org.apache.myfaces.view.facelets.pool.ViewStructureMetadata;

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

 import org.apache.myfaces.view.facelets.tag.jsf.PartialMethodExpressionActionListener;

 import org.apache.myfaces.view.facelets.tag.jsf.PartialMethodExpressionValidator;

 import org.apache.myfaces.view.facelets.tag.jsf.PartialMethodExpressionValueChangeListener;

 import org.apache.myfaces.view.facelets.util.FaceletsViewDeclarationLanguageUtils;

 /**

  * This class represents the abstraction of Facelets as a ViewDeclarationLanguage.

  *

  * @author Simon Lessard (latest modification by $Author$)

  * @version $Revision$ $Date$

  *

  * @since 2.0

  */

 public class FaceletViewDeclarationLanguage extends FaceletViewDeclarationLanguageBase

 {

     //private static final Log log = LogFactory.getLog(FaceletViewDeclarationLanguage.class);

     private static final Logger log = Logger.getLogger(FaceletViewDeclarationLanguage.class.getName());

     private static final Class<?>[] EMPTY_CLASS_ARRAY = new Class<?>[0];

     private static final Class<?>[] VALUE_CHANGE_LISTENER_SIGNATURE = new Class[]{ValueChangeEvent.class};

     private static final Class<?>[] ACTION_LISTENER_SIGNATURE = new Class[]{ActionEvent.class};

     private static final Class<?>[] VALIDATOR_SIGNATURE

             = new Class[]{FacesContext.class, UIComponent.class, Object.class};

     public static final String CHARACTER_ENCODING_KEY = "javax.faces.request.charset";

     public final static long DEFAULT_REFRESH_PERIOD = 0;

     public final static long DEFAULT_REFRESH_PERIOD_PRODUCTION = -1;

     public final static String DEFAULT_CHARACTER_ENCODING = "UTF-8";

     /**

      * Define the default buffer size value passed to ExternalContext.setResponseBufferResponse() and in a

      * servlet environment to HttpServletResponse.setBufferSize().

      */

     @JSFWebConfigParam(since = "2.0", deprecated = true, classType = "java.lang.Integer")

     private final static String PARAM_BUFFER_SIZE_DEPRECATED = "facelets.BUFFER_SIZE";

     private final static String[] PARAMS_BUFFER_SIZE = {ViewHandler.FACELETS_BUFFER_SIZE_PARAM_NAME,

         PARAM_BUFFER_SIZE_DEPRECATED};

     //private final static String PARAM_BUILD_BEFORE_RESTORE = "facelets.BUILD_BEFORE_RESTORE";

     /**

      * Constant used by EncodingHandler to indicate the current encoding of the page being built,

      * and indicate which one is the response encoding on getResponseEncoding(FacesContext, String) method.

      */

     public final static String PARAM_ENCODING = "facelets.Encoding";

     /**

      * Define the period used to refresh the facelet abstract syntax tree from the view definition file. 

      *

      * <p>By default is infinite (no active).</p>

      */

     @JSFWebConfigParam(since = "2.0", defaultValue = "-1", deprecated = true)

     public final static String PARAM_REFRESH_PERIOD_DEPRECATED = "facelets.REFRESH_PERIOD";

     public final static String[] PARAMS_REFRESH_PERIOD = {ViewHandler.FACELETS_REFRESH_PERIOD_PARAM_NAME,

         PARAM_REFRESH_PERIOD_DEPRECATED};

     /**

      * Class implementing ResourceResolver interface used to locate facelet resources. 

      */

     @JSFWebConfigParam(since = "2.0", alias = "facelets.RESOURCE_RESOLVER")

     public final static String PARAM_RESOURCE_RESOLVER = "javax.faces.FACELETS_RESOURCE_RESOLVER";

     /**

      * Class implementing ResourceResolver interface used to locate facelet resources.

      */

     @JSFWebConfigParam(since = "2.0", deprecated = true)

     private final static String PARAM_RESOURCE_RESOLVER_DEPRECATED = "facelets.RESOURCE_RESOLVER";

     private final static String[] PARAMS_RESOURCE_RESOLVER

             = {PARAM_RESOURCE_RESOLVER, PARAM_RESOURCE_RESOLVER_DEPRECATED};

     @JSFWebConfigParam(since = "2.1", defaultValue = "false", expectedValues = "true, false", tags = "performance")

     private final static String PARAM_MARK_INITIAL_STATE_WHEN_APPLY_BUILD_VIEW

             = "org.apache.myfaces.MARK_INITIAL_STATE_WHEN_APPLY_BUILD_VIEW";

     public final static String FILLED_VIEW = "org.apache.myfaces.FILLED_VIEW";

     //BEGIN CONSTANTS SET ON BUILD VIEW

     public final static String BUILDING_VIEW_METADATA = "org.apache.myfaces.BUILDING_VIEW_METADATA";

     public final static String REFRESHING_TRANSIENT_BUILD = "org.apache.myfaces.REFRESHING_TRANSIENT_BUILD";

     public final static String REFRESH_TRANSIENT_BUILD_ON_PSS = "org.apache.myfaces.REFRESH_TRANSIENT_BUILD_ON_PSS";

     public final static String USING_PSS_ON_THIS_VIEW = "org.apache.myfaces.USING_PSS_ON_THIS_VIEW";

     public final static String REMOVING_COMPONENTS_BUILD = "org.apache.myfaces.REMOVING_COMPONENTS_BUILD";

     //END CONSTANTS SET ON BUILD VIEW

     /**

      * Marker to indicate tag handlers the view currently being built is using

      * partial state saving and it is necessary to call UIComponent.markInitialState

      * after component instances are populated. 

      */

     public final static String MARK_INITIAL_STATE_KEY = "org.apache.myfaces.MARK_INITIAL_STATE";

     public final static String IS_BUILDING_INITIAL_STATE_KEY_ALIAS

             = "javax.faces.view.ViewDeclarationLanguage.IS_BUILDING_INITIAL_STATE";

     public final static String CLEAN_TRANSIENT_BUILD_ON_RESTORE

             = "org.apache.myfaces.CLEAN_TRANSIENT_BUILD_ON_RESTORE";

     private final static String STATE_KEY = "<!--@@JSF_FORM_STATE_MARKER@@-->";

     private final static int STATE_KEY_LEN = STATE_KEY.length();

     private static final Set<VisitHint> VISIT_HINTS_DYN_REFRESH = Collections.unmodifiableSet( 

             EnumSet.of(VisitHint.SKIP_ITERATION));

     /**

      * Key used to cache component ids for the counter

      */

     public final static String CACHED_COMPONENT_IDS = "oam.CACHED_COMPONENT_IDS"; 

     private static final String ASTERISK = "*";

     private int _bufferSize;

     // This param evolve in jsf 2.0 to partial state saving

     //private boolean _buildBeforeRestore = false;

     private ViewHandlerSupport _cachedViewHandlerSupport;

     private String _defaultSuffix;

     private FaceletFactory _faceletFactory;

     private StateManagementStrategy _stateMgmtStrategy;

     private RenderKitFactory _renderKitFactory = null;

     private boolean _partialStateSaving;

     private boolean _refreshTransientBuildOnPSS;

     private boolean _refreshTransientBuildOnPSSAuto;

     private Set<String> _viewIds;

     private boolean _markInitialStateWhenApplyBuildView;

     private final ViewDeclarationLanguageStrategy _strategy;

     private ResourceResolver _resourceResolver;

     private Map<String, List<String>> _contractMappings;

     private List<String> _prefixWildcardKeys;

     private FaceletsCompilerSupport _faceletsCompilerSupport;

     private MyfacesConfig _config;

     private ViewPoolProcessor _viewPoolProcessor;

     /**

      *

      */

     public FaceletViewDeclarationLanguage(FacesContext context)

     {

         _config = MyfacesConfig.getCurrentInstance(context.getExternalContext());

         initialize(context);

         _strategy = new FaceletViewDeclarationLanguageStrategy();

     }

     public FaceletViewDeclarationLanguage(FacesContext context, ViewDeclarationLanguageStrategy strategy)

     {

         _config = MyfacesConfig.getCurrentInstance(context.getExternalContext());

         initialize(context);

         _strategy = strategy;

     }

     @Override

     public String getId()

     {

         return ViewDeclarationLanguage.FACELETS_VIEW_DECLARATION_LANGUAGE_ID;

     }

     @Override

     public boolean viewExists(FacesContext facesContext, String viewId)

     {

         if (_strategy.handles(viewId))

         {

             return _resourceResolver.resolveUrl(viewId) != null;

         }

         return false;

     }

     private RestoreViewFromPoolResult tryRestoreViewFromCache(FacesContext context, UIViewRoot view)

     {

         if (_viewPoolProcessor != null)

         {

             ViewPool viewPool = _viewPoolProcessor.getViewPool(context, view);

             if (viewPool != null)

             {

                 ViewStructureMetadata metadata = viewPool.retrieveStaticViewStructureMetadata(context, view);

                 if (metadata != null)

                 {

                     ViewEntry entry = viewPool.popStaticOrPartialStructureView(context, view);

                     if (entry != null)

                     {

                         _viewPoolProcessor.cloneAndRestoreView(context, view, entry, metadata);

                         return entry.getResult();

                     }

                 }

             }

         }

         return null;

     }

     /**

      * {@inheritDoc}

      */

     @Override

     public void buildView(FacesContext context, UIViewRoot view) throws IOException

     {

         if (isFilledView(context, view))

         {

             if (view != null && 

                 FaceletViewDeclarationLanguageBase.isDynamicComponentRefreshTransientBuildActive(context, view))

             {

                 // don't return

             }

             else

             {

                 return;

             }

         }

         // setup our viewId

         String previousViewId = view.getViewId();

         String renderedViewId = getRenderedViewId(context, previousViewId);

         if (renderedViewId == null)

         {

             view.setViewId(renderedViewId);

         }

         else if (!renderedViewId.equals(previousViewId))

         {

             view.setViewId(renderedViewId);

         }

         if (log.isLoggable(Level.FINEST))

         {

             log.finest("Building View: " + renderedViewId);

         }

         boolean usePartialStateSavingOnThisView = _usePartialStateSavingOnThisView(renderedViewId);

         boolean refreshTransientBuild = (view.getChildCount() > 0);

         boolean refreshTransientBuildOnPSS = (usePartialStateSavingOnThisView && _refreshTransientBuildOnPSS);

         boolean refreshPartialView = false;

         if (_viewPoolProcessor != null && !refreshTransientBuild)

         {

             RestoreViewFromPoolResult result = tryRestoreViewFromCache(context, view);

             if (result != null)

             {

                 // Since all transient stuff has been removed, add listeners that keep

                 // track of tree updates.

                 if (RestoreViewFromPoolResult.COMPLETE.equals(result))

                 {

                     if (!PhaseId.RESTORE_VIEW.equals(context.getCurrentPhaseId()))

                     {

                         ((DefaultFaceletsStateManagementStrategy) 

                                 getStateManagementStrategy(context, view.getViewId())).

                                 suscribeListeners(view);

                     }

                     // If the result is complete, the view restored here is static. 

                     // static views can be marked as filled.

                     if (!refreshTransientBuildOnPSS)

                     {

                         // This option will be true on this cases:

                         // -pss is true and refresh is not active

                         setFilledView(context, view);

                     }

                     //At this point refreshTransientBuild = false && refreshTransientBuildOnPSS is true

                     else if (_refreshTransientBuildOnPSSAuto &&

                              !context.getAttributes().containsKey(CLEAN_TRANSIENT_BUILD_ON_RESTORE))

                     {

                         setFilledView(context, view);

                     }

                     return;

                 }

                 else

                 {

                     // We need to refresh a partial view.

                     refreshTransientBuild = true;

                     refreshPartialView = true;

                 }

             }

         }

         if (usePartialStateSavingOnThisView)

         {

             // Before apply we need to make sure the current view has

             // a clientId that will be used as a key to save and restore

             // the current view. Note that getClientId is never called (or used)

             // from UIViewRoot.

             if (view.getId() == null)

             {

                 view.setId(view.createUniqueId(context, null));

             }

             context.getAttributes().put(USING_PSS_ON_THIS_VIEW, Boolean.TRUE);

             //Add a key to indicate ComponentTagHandlerDelegate to 

             //call UIComponent.markInitialState after it is populated

             if (!refreshTransientBuild || refreshPartialView)

             {

                 context.getAttributes().put(StateManager.IS_BUILDING_INITIAL_STATE, Boolean.TRUE);

                 context.getAttributes().put(IS_BUILDING_INITIAL_STATE_KEY_ALIAS, Boolean.TRUE);

             }

             if (!refreshTransientBuild && _markInitialStateWhenApplyBuildView)

             {

                 context.getAttributes().put(MARK_INITIAL_STATE_KEY, Boolean.TRUE);

             }

             if (refreshTransientBuildOnPSS)

             {

                 //This value is only set when _refreshTransientBuildOnPSSMode is "auto" or "true" 

                 context.getAttributes().put(REFRESH_TRANSIENT_BUILD_ON_PSS,

                                             _refreshTransientBuildOnPSSAuto ? "auto" : "true");

             }

         }

         try

         {

             if (refreshTransientBuild)

             {

                 context.getAttributes().put(REFRESHING_TRANSIENT_BUILD, Boolean.TRUE);

                 // In theory, this should be disabled on ComponentTagHandlerDelegate,

                 // otherwise we could lost PostAddToViewEvent / PreRemoveFromViewEvent

                 // caused by c:if effect or facelets cleanup algorithm

                 //context.setProcessingEvents(false);

             }

             // populate UIViewRoot

             _getFacelet(context, renderedViewId).apply(context, view);

         }

         finally

         {

             if (refreshTransientBuildOnPSS)

             {

                 context.getAttributes().remove(REFRESH_TRANSIENT_BUILD_ON_PSS);

             }

             if (refreshTransientBuild)

             {

                 //context.setProcessingEvents(true);

                 if (FaceletViewDeclarationLanguageBase.isDynamicComponentRefreshTransientBuildActive(context))

                 {

                     VisitContext visitContext = (VisitContext) getVisitContextFactory().

                         getVisitContext(context, null, VISIT_HINTS_DYN_REFRESH);

                     view.visitTree(visitContext, new PublishDynamicComponentRefreshTransientBuildCallback());

                 }

                 if (!usePartialStateSavingOnThisView || refreshTransientBuildOnPSS)

                 {

                     // When the facelet is applied, all components are removed and added from view,

                     // but the difference resides in the ordering. Since the view is

                     // being refreshed, if we don't do this manually, some tags like

                     // cc:insertChildren or cc:insertFacet will not work correctly, because

                     // we expect PostAddToViewEvent will be propagated from parent to child, and

                     // facelets refreshing algorithm do the opposite.

                     //FaceletViewDeclarationLanguage._publishPreRemoveFromViewEvent(context, view);

                     //FaceletViewDeclarationLanguage._publishPostAddToViewEvent(context, view);

                     FaceletViewDeclarationLanguage._publishPostBuildComponentTreeOnRestoreViewEvent(context, view);

                 }

                 context.getAttributes().remove(REFRESHING_TRANSIENT_BUILD);

             }

             else

             {

                 // Publish PostAddToView over UIViewRoot, because this is not done automatically.

                 context.getApplication().publishEvent(context, PostAddToViewEvent.class, UIViewRoot.class, view);

             }

         }

         // set this view as filled

         if (refreshTransientBuild)

         {

             //This option will be true on this cases:

             //- pss is false, but we are refreshing

             //- pss is true, and we are refreshing a view already filled

             setFilledView(context, view);

         }

         else if (!refreshTransientBuildOnPSS)

         {

             // This option will be true on this cases:

             // -pss is true and refresh is not active

             setFilledView(context, view);

         }

         //At this point refreshTransientBuild = false && refreshTransientBuildOnPSS is true

         else if (_refreshTransientBuildOnPSSAuto &&

                  !context.getAttributes().containsKey(CLEAN_TRANSIENT_BUILD_ON_RESTORE))

         {

             setFilledView(context, view);

         }

         // Suscribe listeners if we are using partialStateSaving

         if (usePartialStateSavingOnThisView)

         {

             // UIViewRoot.markInitialState() is not called because it does

             // not have a facelet tag handler class that create it, instead

             // new instances are created programatically.

             if (!refreshTransientBuild || refreshPartialView)

             {

                 // Save the state

                 if (_viewPoolProcessor != null &&

                     _viewPoolProcessor.isViewPoolEnabledForThisView(context, view))

                 {

                     _viewPoolProcessor.storeViewStructureMetadata(context, view);

                 }

                 if (_markInitialStateWhenApplyBuildView)

                 {

                     if (!refreshTransientBuildOnPSS ||

                         !view.getAttributes().containsKey(COMPONENT_ADDED_AFTER_BUILD_VIEW))

                     {

                         view.markInitialState();

                     }

                     //Remove the key that indicate we need to call UIComponent.markInitialState

                     //on the current tree

                     context.getAttributes().remove(MARK_INITIAL_STATE_KEY);

                 }

                 else

                 {

                     context.getAttributes().put(MARK_INITIAL_STATE_KEY, Boolean.TRUE);

                     _markInitialStateOnView(view, refreshTransientBuildOnPSS);

                     context.getAttributes().remove(MARK_INITIAL_STATE_KEY);

                 }

                 context.getAttributes().remove(StateManager.IS_BUILDING_INITIAL_STATE);

                 context.getAttributes().remove(IS_BUILDING_INITIAL_STATE_KEY_ALIAS);

             }

             // We need to suscribe the listeners of changes in the component tree

             // only the first time here. Later we suscribe this listeners on

             // DefaultFaceletsStateManagement.restoreView after calling 

             // _publishPostBuildComponentTreeOnRestoreViewEvent(), to ensure 

             // relocated components are not retrieved later on getClientIdsRemoved().

             if (!(refreshTransientBuild && PhaseId.RESTORE_VIEW.equals(context.getCurrentPhaseId())) &&

                 !view.isTransient())

             {

                 ((DefaultFaceletsStateManagementStrategy) getStateManagementStrategy(context, view.getViewId())).

                         suscribeListeners(view);

             }

             context.getAttributes().remove(USING_PSS_ON_THIS_VIEW);

         }

         // Remove this var from faces context because this one prevent AjaxHandler

         // register the standard script library on Post-Redirect-Get pattern or

         // in the next view

         context.getAttributes().remove(AjaxHandler.STANDARD_JSF_AJAX_LIBRARY_LOADED);

     }

     private void _markInitialStateOnView(final UIViewRoot view, final boolean refreshTransientBuildOnPSS)

     {

         if (!refreshTransientBuildOnPSS ||

                 !view.getAttributes().containsKey(COMPONENT_ADDED_AFTER_BUILD_VIEW))

         {

             if (!view.isTransient())

             {

                 view.markInitialState();

             }

         }

         int childCount = view.getChildCount();

         if (childCount > 0)

         {

             for (int i = 0; i < childCount; i++)

             {

                 UIComponent child = view.getChildren().get(i);

                 if (!child.isTransient())

                 {

                     _markInitialState(child);

                 }

             }

         }

         if (view.getFacetCount() > 0)

         {

             Map<String, UIComponent> facetMap = view.getFacets();

             for (Map.Entry<String, UIComponent> entry : facetMap.entrySet())

             {

                 UIComponent child = entry.getValue();

                 if (!child.isTransient())

                 {

                     _markInitialState(child);

                 }

             }

         }

     }

     private void _markInitialState(final UIComponent component)

     {

         component.markInitialState();

         final int childCount = component.getChildCount();

         if (childCount > 0)

         {

             for (int i = 0; i < childCount; i++)

             {

                 UIComponent child = component.getChildren().get(i);

                 if (!child.isTransient())

                 {

                     _markInitialState(child);

                 }

             }

         }

         if (component.getFacetCount() > 0)

         {

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

             for (Map.Entry<String, UIComponent> entry : facetMap.entrySet())

             {

                 UIComponent child = entry.getValue();

                 if (!child.isTransient())

                 {

                     _markInitialState(child);

                 }

             }

         }

     }

     public static void _publishPostBuildComponentTreeOnRestoreViewEvent(FacesContext context, UIComponent component)

     {

         context.getApplication().publishEvent(context, PostBuildComponentTreeOnRestoreViewEvent.class,

                                               component.getClass(), component);

         if (component.getChildCount() > 0)

         {

             // PostAddToViewEvent could cause component relocation

             // (h:outputScript, h:outputStylesheet, composite:insertChildren, composite:insertFacet)

             // so we need to check if the component was relocated or not

             List<UIComponent> children = component.getChildren();

             UIComponent child = null;

             UIComponent currentChild = null;

             int i = 0;

             while (i < children.size())

             {

                 child = children.get(i);

                 // Iterate over the same index if the component was removed

                 // This prevents skip components when processing

                 do

                 {

                     _publishPostBuildComponentTreeOnRestoreViewEvent(context, child);

                     currentChild = child;

                     child = children.get(i);

                 }

                 while ((i < children.size()) && child != currentChild);

                 i++;

             }

         }

         if (component.getFacetCount() > 0)

         {

             for (UIComponent child : component.getFacets().values())

             {

                 _publishPostBuildComponentTreeOnRestoreViewEvent(context, child);

             }

         }

     }

     private boolean isFilledView(FacesContext context, UIViewRoot view)

     {

         // The view is only built on restoreView or renderView, but if

         // we are not using partial state saving, we need to mark the current

         // view as filled, otherwise it will be filled again on renderView.

         return context.getAttributes().containsKey(view);

         // -= Leonardo Uribe =- save this key on view cause render fail, because the view

         // is built before render view to "restore" the transient components that has

         // facelet markup (facelets UIInstructions ...) This effect is only notice when

         // partial state saving is not used. 

         //return view.getAttributes().containsKey(FILLED_VIEW);

     }

     private void setFilledView(FacesContext context, UIViewRoot view)

     {

         context.getAttributes().put(view, Boolean.TRUE);

         // -= Leonardo Uribe =- save this key on view cause render fail, because the view

         // is built before render view to "restore" the transient components that has

         // facelet markup (facelets UIInstructions ...) This effect is only notice when

         // partial state saving is not used. 

         // view.getAttributes().put(FILLED_VIEW, Boolean.TRUE);

     }

     /**

      * retargetMethodExpressions(FacesContext, UIComponent) has some clues about the behavior of this method

      *

      * {@inheritDoc}

      */

     @Override

     public BeanInfo getComponentMetadata(FacesContext context, Resource componentResource)

     {

         BeanInfo beanInfo = null;

         checkNull(context, "context");

         try

         {

             Facelet compositeComponentFacelet;

             FaceletFactory.setInstance(_faceletFactory);

             try

             {

                 compositeComponentFacelet

                         = _faceletFactory.getCompositeComponentMetadataFacelet(componentResource.getURL());

             }

             finally

             {

                 FaceletFactory.setInstance(null);

             }

             //context.getAttributes().put(BUILDING_COMPOSITE_COMPONENT_METADATA, Boolean.TRUE);

             // Create a temporal tree where all components will be put, but we are only

             // interested in metadata.

             UINamingContainer compositeComponentBase

                     = (UINamingContainer) context.getApplication().createComponent(

                     context, UINamingContainer.COMPONENT_TYPE, null);

             // Fill the component resource key, because this information should be available

             // on metadata to recognize which is the component used as composite component base.

             // Since this method is called from Application.createComponent(FacesContext,Resource),

             // and in that specific method this key is updated, this is the best option we

             // have for recognize it (also this key is used by UIComponent.isCompositeComponent)

             compositeComponentBase.getAttributes().put(Resource.COMPONENT_RESOURCE_KEY, componentResource);

             // According to UserTagHandler, in this point we need to wrap the facelet

             // VariableMapper, so local changes are applied on "page context", but

             // data is retrieved from full context

             FaceletContext faceletContext = (FaceletContext) context.

                     getAttributes().get(FaceletContext.FACELET_CONTEXT_KEY);

             VariableMapper orig = faceletContext.getVariableMapper();

             try

             {

                 faceletContext.setVariableMapper(new VariableMapperWrapper(orig));

                 compositeComponentBase.pushComponentToEL(context, compositeComponentBase);

                 compositeComponentFacelet.apply(context, compositeComponentBase);

                 compositeComponentBase.popComponentFromEL(context);

             }

             finally

             {

                 faceletContext.setVariableMapper(orig);

             }

             beanInfo = (BeanInfo) compositeComponentBase.getAttributes().get(UIComponent.BEANINFO_KEY);

         }

         catch (IOException e)

         {

             throw new FacesException(e);

         }

         //finally

         //{

         //context.getAttributes().remove(BUILDING_COMPOSITE_COMPONENT_METADATA);

         //}

         return beanInfo;

     }

     /**

      * Check if the current facelet applied is used to build composite component metadata.

      *

      * @param context

      * @return

      */

     //public static boolean isBuildingCompositeComponentMetadata(FacesContext context)

     //{

     //    return context.getAttributes().containsKey(BUILDING_COMPOSITE_COMPONENT_METADATA);

     //}

     /**

      * Check if the current facelet applied is used to build view metadata.

      *

      * @param context

      * @return

      */

     public static boolean isBuildingViewMetadata(FacesContext context)

     {

         return context.getAttributes().containsKey(BUILDING_VIEW_METADATA);

     }

     public static boolean isRefreshingTransientBuild(FacesContext context)

     {

         return context.getAttributes().containsKey(REFRESHING_TRANSIENT_BUILD);

     }

     public static boolean isRemovingComponentBuild(FacesContext context)

     {

         return context.getAttributes().containsKey(REMOVING_COMPONENTS_BUILD);

     }

     public static boolean isMarkInitialState(FacesContext context)

     {

         return Boolean.TRUE.equals(context.getAttributes().get(MARK_INITIAL_STATE_KEY));

     }

     public static boolean isRefreshTransientBuildOnPSS(FacesContext context)

     {

         //this include both "true" and "auto"

         return context.getAttributes().containsKey(REFRESH_TRANSIENT_BUILD_ON_PSS);

     }

     public static boolean isRefreshTransientBuildOnPSSAuto(FacesContext context)

     {

         return "auto".equalsIgnoreCase((String) context.getAttributes().get(REFRESH_TRANSIENT_BUILD_ON_PSS));

     }

     public static boolean isCleanTransientBuildOnRestore(FacesContext context)

     {

         return context.getAttributes().containsKey(CLEAN_TRANSIENT_BUILD_ON_RESTORE);

     }

     public static void cleanTransientBuildOnRestore(FacesContext context)

     {

         context.getAttributes().put(CLEAN_TRANSIENT_BUILD_ON_RESTORE, Boolean.TRUE);

     }

     public static boolean isUsingPSSOnThisView(FacesContext context)

     {

         return context.getAttributes().containsKey(USING_PSS_ON_THIS_VIEW);

     }

     /**

      * In short words, this method take care of "target" an "attached object".

      * <ul>

      * <li>The "attached object" is instantiated by a tag handler.</li> 

      * <li>The "target" is an object used as "marker", that exposes a List<UIComponent></li>

      * </ul>

      * This method should be called from some composite component tag handler, after

      * all children of composite component has been applied.

      */

     @Override

     @SuppressWarnings("unchecked")

     public void retargetAttachedObjects(FacesContext context,

                                         UIComponent topLevelComponent, List<AttachedObjectHandler> handlerList)

     {

         checkNull(context, "context");

         checkNull(topLevelComponent, "topLevelComponent");

         checkNull(handlerList, "handlerList");

         BeanInfo compositeComponentMetadata

                 = (BeanInfo) topLevelComponent.getAttributes().get(UIComponent.BEANINFO_KEY);

         if (compositeComponentMetadata == null)

         {

             log.severe("Composite component metadata not found for: " + topLevelComponent.getClientId(context));

             return;

         }

         BeanDescriptor compositeComponentDescriptor = compositeComponentMetadata.getBeanDescriptor();

         List<AttachedObjectTarget> targetList = (List<AttachedObjectTarget>)

                 compositeComponentDescriptor.getValue(AttachedObjectTarget.ATTACHED_OBJECT_TARGETS_KEY);

         if (targetList == null || targetList.isEmpty())

         {

             return;

         }

         for (int i = 0, size = handlerList.size(); i < size; i++)

         {

             AttachedObjectHandler currentHandler = handlerList.get(i);

             // In the spec javadoc this variable is referred as forAttributeValue, but

             // note it is also called curTargetName

             String forValue = currentHandler.getFor();

             // perf: targetList is always arrayList: see AttachedObjectTargetHandler.apply 

             // and ClientBehaviorHandler.apply 

             for (int k = 0, targetsSize = targetList.size(); k < targetsSize; k++)

             {

                 AttachedObjectTarget currentTarget = targetList.get(k);

                 FaceletCompositionContext mctx = FaceletCompositionContext.getCurrentInstance();

                 if ((forValue != null && forValue.equals(currentTarget.getName())) &&

                         ((currentTarget instanceof ActionSource2AttachedObjectTarget &&

                                 currentHandler instanceof ActionSource2AttachedObjectHandler) ||

                                 (currentTarget instanceof EditableValueHolderAttachedObjectTarget &&

                                         currentHandler instanceof EditableValueHolderAttachedObjectHandler) ||

                                 (currentTarget instanceof ValueHolderAttachedObjectTarget &&

                                         currentHandler instanceof ValueHolderAttachedObjectHandler)))

                 {

                     // perf: getTargets return ArrayList - see getTargets implementations

                     List<UIComponent> targets = currentTarget.getTargets(topLevelComponent);

                     for (int l = 0, targetsCount = targets.size(); l < targetsCount; l++)

                     {

                         UIComponent component = targets.get(l);

                         // If we found composite components when traverse the tree

                         // we have to call this one recursively, because each composite component

                         // should have its own AttachedObjectHandler list, filled earlier when

                         // its tag handler is applied.

                         if (UIComponent.isCompositeComponent(component))

                         {

                             // How we obtain the list of AttachedObjectHandler for

                             // the current composite component? It should be a component

                             // attribute or retrieved by a key inside component.getAttributes

                             // map. Since api does not specify any attribute, we suppose

                             // this is an implementation detail and it should be retrieved

                             // from component attribute map.

                             // But this is only the point of the iceberg, because we should

                             // define how we register attached object handlers in this list.

                             // ANS: see CompositeComponentResourceTagHandler.

                             // The current handler should be added to the list, to be chained.

                             // Note that the inner component should have a target with the same name

                             // as "for" attribute

                             mctx.addAttachedObjectHandler(component, currentHandler);

                             List<AttachedObjectHandler> handlers = mctx.getAttachedObjectHandlers(component);

                             retargetAttachedObjects(context, component, handlers);

                             handlers.remove(currentHandler);

                         }

                         else

                         {

                             currentHandler.applyAttachedObject(context, component);

                         }

                         if (mctx.isUsingPSSOnThisView() && mctx.isMarkInitialState())

                         {

                             component.markInitialState();

                         }

                     }

                 }

                 else if ((currentTarget instanceof BehaviorHolderAttachedObjectTarget &&

                         currentHandler instanceof BehaviorHolderAttachedObjectHandler))

                 {

                     String eventName = ((BehaviorHolderAttachedObjectHandler) currentHandler).getEventName();

                     boolean isDefaultEvent = ((BehaviorHolderAttachedObjectTarget) currentTarget).isDefaultEvent();

                     if ((eventName != null && eventName.equals(currentTarget.getName())) ||

                             (eventName == null && isDefaultEvent))

                     {

                         List<UIComponent> targets = currentTarget.getTargets(topLevelComponent);

                         for (int j = 0, targetssize = targets.size(); j < targetssize; j++)

                         {

                             UIComponent component = targets.get(j);

                             // If we found composite components when traverse the tree

                             // we have to call this one recursively, because each composite component

                             // should have its own AttachedObjectHandler list, filled earlier when

                             // its tag handler is applied.

                             if (UIComponent.isCompositeComponent(component))

                             {

                                 if (currentTarget instanceof ClientBehaviorAttachedObjectTarget)

                                 {

                                     mctx.addAttachedObjectHandler(component,

                                             new ClientBehaviorRedirectBehaviorAttachedObjectHandlerWrapper(

                                                     (BehaviorHolderAttachedObjectHandler) currentHandler,

                                                     ((ClientBehaviorAttachedObjectTarget) currentTarget).getEvent()));

                                 }

                                 else

                                 {

                                     mctx.addAttachedObjectHandler(component, currentHandler);

                                 }

                                 List<AttachedObjectHandler> handlers = mctx.getAttachedObjectHandlers(component);

                                 retargetAttachedObjects(context, component, handlers);

                                 handlers.remove(currentHandler);

                             }

                             else

                             {

                                 if (currentHandler instanceof

                                         ClientBehaviorRedirectBehaviorAttachedObjectHandlerWrapper)

                                 {

                                     currentHandler.applyAttachedObject(context,

                                             new ClientBehaviorRedirectEventComponentWrapper(component,

                                             ((ClientBehaviorRedirectBehaviorAttachedObjectHandlerWrapper)

                                                     currentHandler).getWrappedEventName(), eventName));

                                 }

                                 else

                                 {

                                     currentHandler.applyAttachedObject(context, component);

                                 }

                             }

                             if (mctx.isUsingPSSOnThisView() && mctx.isMarkInitialState())

                             {

                                 component.markInitialState();

                             }

                         }

                     }

                 }

             }

         }

     }

     @Override

     public void retargetMethodExpressions(FacesContext context, UIComponent topLevelComponent)

     {

         checkNull(context, "context");

         BeanInfo compositeComponentMetadata

                 = (BeanInfo) topLevelComponent.getAttributes().get(UIComponent.BEANINFO_KEY);

         if (compositeComponentMetadata == null)

         {

             log.severe("Composite component metadata not found for: " + topLevelComponent.getClientId(context));

             return;

         }

         // "...For each attribute that is a MethodExpression..." This means we have to scan

         // all attributes with "method-signature" attribute and no "type" attribute

         // javax.faces.component._ComponentAttributesMap uses BeanInfo.getPropertyDescriptors to

         // traverse over it, but here the metadata returned by UIComponent.BEANINFO_KEY is available

         // only for composite components.

         // That means somewhere we need to create a custom BeanInfo object for composite components

         // that will be filled somewhere (theorically in ViewDeclarationLanguage.getComponentMetadata())

         PropertyDescriptor[] propertyDescriptors = compositeComponentMetadata.getPropertyDescriptors();

         ELContext elContext = (ELContext) context.getAttributes().get(FaceletContext.FACELET_CONTEXT_KEY);

         for (PropertyDescriptor propertyDescriptor : propertyDescriptors)

         {

             if (propertyDescriptor.getValue("type") != null)

             {

                 // This check is necessary if we have both "type" and "method-signature" set.

                 // In that case, "method-signature" is ignored

                 continue;

             }

             String attributeName = propertyDescriptor.getName();

             //boolean isKnownMethod = "action".equals(attributeName) || "actionListener".equals(attributeName)  

             //        || "validator".equals(attributeName) || "valueChangeListener".equals(attributeName);

             // <composite:attribute> method-signature attribute is 

             // ValueExpression that must evaluate to String

             ValueExpression methodSignatureExpression

                     = (ValueExpression) propertyDescriptor.getValue("method-signature");

             String methodSignature = null;

             if (methodSignatureExpression != null)

             {

                 // Check if the value expression holds a method signature

                 // Note that it could be null, so in that case we don't have to do anything

                 methodSignature = (String) methodSignatureExpression.getValue(elContext);

             }

             String targetAttributeName = null;

             ValueExpression targetAttributeNameVE

                     = (ValueExpression) propertyDescriptor.getValue("targetAttributeName");

             if (targetAttributeNameVE != null)

             {

                 targetAttributeName = (String) targetAttributeNameVE.getValue(context.getELContext());

                 if (targetAttributeName == null)

                 {

                     targetAttributeName = attributeName;

                 }

             }

             else

             {

                 targetAttributeName = attributeName;

             }

             boolean isKnownTargetAttributeMethod

                     = "action".equals(targetAttributeName) || "actionListener".equals(targetAttributeName)

                       || "validator".equals(targetAttributeName) || "valueChangeListener".equals(targetAttributeName);

             // either the attributeName has to be a knownMethod or there has to be a method-signature

             if (isKnownTargetAttributeMethod || methodSignature != null)

             {

                 ValueExpression targetsExpression =

                         (ValueExpression) propertyDescriptor.getValue("targets");

                 String targets = null;

                 // <composite:attribute> targets attribute is 

                 // ValueExpression that must evaluate to String

                 if (targetsExpression != null)

                 {

                     targets = (String) targetsExpression.getValue(elContext);

                 }

                 if (targets == null)

                 {

                     // "...let the name of the metadata element be the 

                     // evaluated value of the targets attribute..."

                     targets = attributeName;

                 }

                 FaceletCompositionContext mctx = FaceletCompositionContext.getCurrentInstance();

                 // If the MethodExpression attribute has been already applied, there is no need to

                 // handle it and it is probably a MethodExpression instance is on attribute map, so the

                 // inner code will cause a ClassCastException.

                 if (!mctx.isMethodExpressionAttributeApplied(topLevelComponent, attributeName))

                 {

                     ValueExpression attributeNameValueExpression =

                             (ValueExpression) topLevelComponent.getAttributes().get(attributeName);

                     if (attributeNameValueExpression == null)

                     {

                         // composite:attribute has a default property, so if we can't found on the

                         // component attribute map, we should get the default as CompositeComponentELResolver

                         // does.

                         attributeNameValueExpression = (ValueExpression) propertyDescriptor.getValue("default");

                         if (attributeNameValueExpression == null)

                         {

                             // It is only valid to log an error if the attribute is required

                             ValueExpression ve = (ValueExpression) propertyDescriptor.getValue("required");

                             if (ve != null)

                             {

                                 Object requiredValue = ve.getValue(elContext);

                                 Boolean required = null;

                                 if (requiredValue instanceof Boolean)

                                 {

                                     required = (Boolean) requiredValue;

                                 }

                                 else

                                 {

                                     required = Boolean.valueOf(requiredValue.toString());

                                 }

                                 if (required != null && required.booleanValue())

                                 {

                                     if (log.isLoggable(Level.SEVERE))

                                     {

                                         log.severe("attributeValueExpression not found under the key \""

                                                    + attributeName

                                                    + "\". Looking for the next attribute");

                                     }

                                 }

                             }

                             continue;

                         }

                     }

                     String[] targetsArray = StringUtils.splitShortString(targets, ' ');

                     String attributeExpressionString = attributeNameValueExpression.getExpressionString();

                     //Check if the stored valueExpression is a ccRedirection, to handle it properly later.

                     boolean ccAttrMeRedirection =

                             attributeNameValueExpression instanceof LocationValueExpression &&

                                     CompositeComponentELUtils.isCompositeComponentAttrsMethodExpression(

                                             attributeNameValueExpression.getExpressionString());

                     if (isKnownTargetAttributeMethod)

                     {

                         // To add support to #{cc.attrs.action}, #{cc.attrs.actionListener}, #{cc.attrs.validator} or

                         // #{cc.attrs.valueChangeListener} it is necessary to put a MethodExpression or a 

                         // ValueExpression pointing to the associated java method in the component attribute map.

                         // org.apache.myfaces.view.facelets.tag.composite.RetargetMethodExpressionRule already put

                         // a ValueExpression, so we only need to put a MethodExpression when a non redirecting

                         // expression is used (for example when a nested #{cc.attrs.xxx} is used).

                         if ("action".equals(targetAttributeName))

                         {

                             applyActionMethodExpressionEL(context, elContext,

                                     topLevelComponent, attributeName,

                                     attributeExpressionString, attributeNameValueExpression,

                                     ccAttrMeRedirection);

                         }

                         else if ("actionListener".equals(targetAttributeName))

                         {

                             applyActionListenerMethodExpressionEL(context, elContext,

                                     topLevelComponent, attributeName, 

                                     attributeExpressionString, attributeNameValueExpression, 

                                     ccAttrMeRedirection);

                         }

                         else if ("validator".equals(targetAttributeName))

                         {

                             applyValidatorMethodExpressionEL(context, elContext,

                                     topLevelComponent, attributeName,

                                     attributeExpressionString, attributeNameValueExpression, 

                                     ccAttrMeRedirection);

                         }

                         else if ("valueChangeListener".equals(targetAttributeName))

                         {

                             applyValueChangeListenerMethodExpressionEL(context, elContext,

                                     topLevelComponent, attributeName, 

                                     attributeExpressionString, attributeNameValueExpression,

                                     ccAttrMeRedirection);

                         }

                         UIComponent topLevelComponentBase = 

                             topLevelComponent.getFacet(UIComponent.COMPOSITE_FACET_NAME);

                         for (String target : targetsArray)

                         {

                             UIComponent innerComponent

                                     = ComponentSupport.findComponentChildOrFacetFrom(context, topLevelComponentBase,

                                                                                      target);

                             if (innerComponent == null)

                             {

                                 continue;

                             }

                             if (isCompositeComponentRetarget(context, innerComponent, targetAttributeName))

                             {

                                 innerComponent.getAttributes().put(targetAttributeName, attributeNameValueExpression);

                                 mctx.clearMethodExpressionAttribute(innerComponent, targetAttributeName);

                                 retargetMethodExpressions(context, innerComponent);

                                 if (mctx.isUsingPSSOnThisView() && mctx.isMarkInitialState())

                                 {

                                     innerComponent.markInitialState();

                                 }

                             }

                             else

                             {

                                 if ("action".equals(targetAttributeName))

                                 {

                                     applyActionMethodExpressionTarget(context, mctx, elContext,

                                             topLevelComponentBase, innerComponent, 

                                             attributeName, targetAttributeName, 

                                             attributeExpressionString, attributeNameValueExpression, 

                                             ccAttrMeRedirection);

                                     if (mctx.isUsingPSSOnThisView() && mctx.isMarkInitialState())

                                     {

                                         innerComponent.markInitialState();

                                     }

                                 }

                                 else if ("actionListener".equals(targetAttributeName))

                                 {

                                     applyActionListenerMethodExpressionTarget(context, mctx, elContext, 

                                             topLevelComponentBase, innerComponent, 

                                             attributeName, targetAttributeName, 

                                             attributeExpressionString, attributeNameValueExpression, 

                                             ccAttrMeRedirection);

                                     if (mctx.isUsingPSSOnThisView() && mctx.isMarkInitialState())

                                     {

                                         innerComponent.markInitialState();

                                     }

                                 }

                                 else if ("validator".equals(targetAttributeName))

                                 {

                                     applyValidatorMethodExpressionTarget(context, mctx, elContext,

                                             topLevelComponentBase, innerComponent, 

                                             attributeName, targetAttributeName, 

                                             attributeExpressionString, attributeNameValueExpression, 

                                             ccAttrMeRedirection);

                                     if (mctx.isUsingPSSOnThisView() && mctx.isMarkInitialState())

                                     {

                                         innerComponent.markInitialState();

                                     }

                                 }

                                 else if ("valueChangeListener".equals(targetAttributeName))

                                 {

                                     applyValueChangeListenerMethodExpressionTarget(context, mctx, elContext,

                                             topLevelComponentBase, innerComponent, 

                                             attributeName, targetAttributeName,

                                             attributeExpressionString, attributeNameValueExpression,

                                             ccAttrMeRedirection);

                                     if (mctx.isUsingPSSOnThisView() && mctx.isMarkInitialState())

                                     {

                                         innerComponent.markInitialState();

                                     }

                                 }

                             }

                         }

                     }

                     else

                     {

                         MethodExpression methodExpression = null;

                         // composite:attribute targets property only has sense for action, actionListener,

                         // validator or valueChangeListener. This means we have to retarget the method expression

                         // to the topLevelComponent.

                         // Since a MethodExpression has no state, we can use it multiple times without problem, so

                         // first create it here.

                         methodSignature = methodSignature.trim();

                         methodExpression = context.getApplication().getExpressionFactory().

                                 createMethodExpression(elContext,

                                         attributeExpressionString, 

                                         FaceletsViewDeclarationLanguageUtils.getReturnType(methodSignature),