Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source
   * Copyright 2009, Red Hat, Inc. and individual contributors
   * by the @authors tag. See the copyright.txt in the distribution for a
   * full listing of individual contributors.
   *
   * This is free software; you can redistribute it and/or modify it
   * under the terms of the GNU Lesser General Public License as
   * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * This software is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this software; if not, write to the Free
  * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
  */
 package org.richfaces.renderkit;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 import  javax.faces.application.Application;
 import  javax.faces.application.Resource;
 import  javax.faces.application.ResourceHandler;
 import  javax.faces.component.UIComponent;
 import  javax.faces.component.UIComponentBase;
 import  javax.faces.component.behavior.ClientBehavior;
 import  javax.faces.component.behavior.ClientBehaviorContext;
 import  javax.faces.component.behavior.ClientBehaviorHint;
 import  javax.faces.component.behavior.ClientBehaviorHolder;
 import  javax.faces.context.ExternalContext;
 import  javax.faces.context.FacesContext;
 import  javax.faces.context.ResponseWriter;
 
 import  org.ajax4jsf.javascript.JSFunctionDefinition;
 import  org.ajax4jsf.javascript.ScriptUtils;

Author(s):
Nick Belaevski
 
 public final class RenderKitUtils {
    
 
     static final String BEHAVIOR_SOURCE_ID = "javax.faces.source";
    
 
     static final String BEHAVIOR_EVENT_NAME = "javax.faces.behavior.event";
    
 
     private static final String XHTML_ATTRIBUTE_PREFIX = "xml:";
    
 
     private static final String XHTML_CONTENT_TYPE = "application/xhtml+xml";
     // TODO - check what's in MyFaces
     private static final String ATTRIBUTES_THAT_ARE_SET = UIComponentBase.class.getName() + ".attributesThatAreSet";
     private static final String[] BOOLEAN_ATTRIBUTE_NAMES = { "checked""compact""declare""defer""disabled""ismap",
             "multiple""nohref""noshade""nowrap""readonly""selected" };
     private static final String[] URI_ATTRIBUTE_NAMES = { "action""background""cite""classid""codebase""data",
             "href""longdesc""profile""src""usemap" };
     private static final String[] XHTML_ATTRIBUTE_NAMES = { "lang" };
     private static final String DISABLED_ATTRIBUTE_NAME = "disabled";

    
Wrapper class around object value used to transform values into particular JS objects

Author(s):
Nick Belaevski
Since:
3.3.2
 
     public enum ScriptHashVariableWrapper {

        
No-op default wrapper
 
         noop {
             @Override
             Object wrap(Object o) {
                 return o;
             }
        },
        
Convert parameter to array of srings.
        asArray {
            @Override
            Object wrap(Object o) {
                return asArray(o);
            }
        },
        
Event handler functions wrapper. Wraps
 functionCode
 
object into:
 function(event) {
   functionCode
 }
 
        eventHandler {
            @Override
            Object wrap(Object o) {
                return new JSFunctionDefinition("event").addToBody(o);
            }
        };

        
Method that does the wrapping

Parameters:
o object to wrap
Returns:
wrapped object
        abstract Object wrap(Object o);
    }
    private RenderKitUtils() {
        // utility constructor
    }
    static String[] asArray(Object object) {
        if (object == null) {
            return null;
        }
        Class<?> componentType = object.getClass().getComponentType();
        if (String.class.equals(componentType)) {
            return (String[]) object;
        } else if (componentType != null) {
            Object[] objects = (Object[]) object;
            String[] result = new String[objects.length];
            for (int i = 0; i < objects.lengthi++) {
                Object o = objects[i];
                if (o == null) {
                    continue;
                }
                result[i] = o.toString();
            }
            return result;
        } else if (object instanceof Collection) {
            Collection<?> collection = (Collection<?>) object;
            String[] result = new String[collection.size()];
            Iterator<?> iterator = collection.iterator();
            for (int i = 0; i < result.lengthi++) {
                Object next = iterator.next();
                if (next == null) {
                    continue;
                }
                result[i] = next.toString();
            }
            return result;
        } else {
            String string = object.toString().trim();
            String[] split = string.split("\\s*,\\s*");
            return split;
        }
    }
    private static Map<StringList<ClientBehavior>> getClientBehaviorsMap(UIComponent component) {
        Map<StringList<ClientBehavior>> result;
        if (component instanceof ClientBehaviorHolder) {
            ClientBehaviorHolder clientBehaviorHolder = (ClientBehaviorHolder) component;
            result = clientBehaviorHolder.getClientBehaviors();
        } else {
            result = Collections.emptyMap();
        }
        return result;
    }
    static boolean isDisabled(UIComponent component) {
        Object disabledAttributeValue = component.getAttributes().get();
        if (disabledAttributeValue == null) {
            return false;
        }
        if (disabledAttributeValue instanceof Boolean) {
            return ..equals(disabledAttributeValue);
        }
        return Boolean.valueOf(disabledAttributeValue.toString());
    }
    static String escape(String s) {
        StringBuilder sb = new StringBuilder(s.length());
        int start = 0;
        int end;
        while ((end = s.indexOf('\''start)) >= 0) {
            sb.append(sstartend);
            sb.append("\\'");
            start = end + 1;
        }
        sb.append(sstarts.length());
        return sb.toString();
    }
    static boolean chain(StringBuilder sbObject objectboolean isChained) {
        if (object != null) {
            String objectString = object.toString().trim();
            if (objectString.length() != 0) {
                final boolean localIsChained;
                if (!isChained && sb.length() != 0) {
                    // extract previously stored handler
                    String previousHandlerString = sb.toString();
                    // clear builder object
                    sb.setLength(0);
                    // append escaped handler
                    sb.append("'");
                    sb.append(escape(previousHandlerString));
                    sb.append("'");
                    localIsChained = true;
                } else {
                    // use passed in value of chained indicator
                    localIsChained = isChained;
                }
                if (localIsChained) {
                    sb.append(",'");
                    sb.append(escape(objectString));
                    sb.append("'");
                    return true;
                } else {
                    sb.append(objectString);
                    return false;
                }
            }
        }
        // no changes, pass chained indicator we initially used
        return isChained;
    }
    private static Object createBehaviorsChain(Object inlineHandlerValue, ClientBehaviorContext behaviorContext,
            List<ClientBehavior> behaviors) {
        boolean isChained = false;
        StringBuilder result = new StringBuilder();
        isChained = chain(resultinlineHandlerValueisChained);
        for (ClientBehavior behavior : behaviors) {
            isChained = chain(resultbehavior.getScript(behaviorContext), isChained);
            if (behavior.getHints().contains(ClientBehaviorHint.SUBMITTING)) {
                break;
            }
        }
        if (result.length() == 0) {
            return null;
        }
        if (isChained) {
            result.insert(0, "return jsf.util.chain(this, event, ");
            result.append(")");
        }
        return result.toString();
    }
    private static boolean isAttributeSet(Object attributeValue) {
        // TODO - consider required attributes with "" value (like 'alt')
        if (attributeValue == null) {
            return false;
        } else if (attributeValue instanceof String) {
            return ((StringattributeValue).length() > 0;
        } else if (attributeValue instanceof Integer && (IntegerattributeValue == .) {
            return false;
        } else if (attributeValue instanceof Double && (DoubleattributeValue == .) {
            return false;
        } else if (attributeValue instanceof Character && (CharacterattributeValue == .) {
            return false;
        } else if (attributeValue instanceof Float && (FloatattributeValue == .) {
            return false;
        } else if (attributeValue instanceof Short && (ShortattributeValue == .) {
            return false;
        } else if (attributeValue instanceof Byte && (ByteattributeValue == .) {
            return false;
        } else if (attributeValue instanceof Long && (LongattributeValue == .) {
            return false;
        } else if (attributeValue instanceof Collection<?> || attributeValue instanceof Map<?, ?>) {
            return true;
        }
        return attributeValue.toString().length() > 0;
    }
    public static boolean shouldRenderAttribute(Object attributeValue) {
        // TODO - consider required attributes with "" value (like 'alt')
        if (!isAttributeSet(attributeValue)) {
            return false;
        }
        if (attributeValue instanceof Boolean && ..equals(attributeValue)) {
            return false;
        }
        return attributeValue.toString().length() > 0;
    }
    public static String prefixAttributeName(String attributeNameboolean isXhtmlMode) {
        if (isXhtmlMode) {
            if (Arrays.binarySearch(attributeName) >= 0) {
                return  + attributeName;
            }
        }
        return attributeName;
    }
    public static String prefixAttributeName(String attributeName, ResponseWriter responseWriter) {
        return prefixAttributeName(attributeName.equals(responseWriter.getContentType()));
    }
    public static void renderAttribute(FacesContext facesContextString attributeNameObject attributeValue)
            throws IOException {
        if (!shouldRenderAttribute(attributeValue)) {
            return;
        }
        ResponseWriter writer = facesContext.getResponseWriter();
        String prefixedAttributeName = prefixAttributeName(attributeNamewriter);
        if (Arrays.binarySearch(attributeName) >= 0) {
            writer.writeURIAttribute(prefixedAttributeNameattributeValuenull);
        } else if (Arrays.binarySearch(attributeName) >= 0) {
            boolean booleanAttributeValue = Boolean.valueOf(String.valueOf(attributeValue));
            if (booleanAttributeValue) {
                // TODO - is passing in Boolean.TRUE value documented somewhere?
                writer.writeAttribute(prefixedAttributeName.null);
            }
        } else {
            writer.writeAttribute(prefixedAttributeNameattributeValuenull);
        }
    }
    // TODO - create special method for event handlers that will return String?
    // TODO - add check for 'disabled'?
    public static Object getAttributeAndBehaviorsValue(FacesContext facesContext, UIComponent component,
            ComponentAttribute componentAttribute) {
        if (facesContext == null) {
            throw new NullPointerException("facesContext");
        }
        if (component == null) {
            throw new NullPointerException("component");
        }
        if (componentAttribute == null) {
            throw new NullPointerException("componentAttribute");
        }
        String componentAttributeName = componentAttribute.getComponentAttributeName();
        Object attributeValue = component.getAttributes().get(componentAttributeName);
        String[] eventNames = componentAttribute.getEventNames();
        if (eventNames.length > 0) {
            Map<StringList<ClientBehavior>> behaviorsMap = getClientBehaviorsMap(component);
            if (behaviorsMap.size() > 0) {
                for (String eventName : eventNames) {
                    if (behaviorsMap.containsKey(eventName)) {
                        List<ClientBehavior> behaviorsList = behaviorsMap.get(eventName);
                        if (!behaviorsList.isEmpty()) {
                            // TODO - parameters handling
                            ClientBehaviorContext behaviorContext = ClientBehaviorContext.createClientBehaviorContext(
                                    facesContextcomponenteventNamenullnull);
                            attributeValue = createBehaviorsChain(attributeValuebehaviorContextbehaviorsList);
                        }
                        break;
                    }
                }
            }
        }
        return attributeValue;
    }
    public static void renderAttributeAndBehaviors(FacesContext facesContext, UIComponent component,
            ComponentAttribute componentAttributethrows IOException {
        Object attributeValue = getAttributeAndBehaviorsValue(facesContextcomponentcomponentAttribute);
        renderAttribute(facesContextcomponentAttribute.getHtmlAttributeName(), attributeValue);
    }
    public static void renderPassThroughAttributesOptimized(FacesContext context, UIComponent component,
            Map<StringComponentAttributeknownAttributesMapthrows IOException {
        Object attributesThatAreSetObject = component.getAttributes().get();
        if (attributesThatAreSetObject instanceof Collection<?>) {
            boolean disabled = isDisabled(component);
            Set<StringhandledAttributes = new HashSet<String>(knownAttributesMap.size());
            Collection<?> attributesThatAreSet = (Collection<?>) attributesThatAreSetObject;
            for (Object attributeNameObject : attributesThatAreSet) {
                if (attributeNameObject == null) {
                    continue;
                }
                String attributeName = attributeNameObject.toString();
                ComponentAttribute knownAttribute = knownAttributesMap.get(attributeName);
                if (knownAttribute != null) {
                    handledAttributes.add(knownAttribute.getHtmlAttributeName());
                    if (disabled && knownAttribute.getEventNames() != null) {
                        continue;
                    }
                    renderAttributeAndBehaviors(contextcomponentknownAttribute);
                }
            }
            // render attributes that haven't been processed yet - there can be behaviors
            for (ComponentAttribute knownAttribute : knownAttributesMap.values()) {
                if (handledAttributes.contains(knownAttribute.getHtmlAttributeName())) {
                    continue;
                }
                renderAttributeAndBehaviors(contextcomponentknownAttribute);
            }
        } else {
            // switch to unoptimized mode
            renderPassThroughAttributes(contextcomponentknownAttributesMap);
        }
    }
    public static void renderPassThroughAttributes(FacesContext context, UIComponent component,
            Map<StringComponentAttributeknownAttributesMapthrows IOException {
        Collection<ComponentAttributeattributes = knownAttributesMap.values();
        renderPassThroughAttributes(contextcomponentattributes);
    }
    public static void renderPassThroughAttributes(FacesContext context, UIComponent component,
            Collection<ComponentAttributeattributesthrows IOException {
        boolean disabled = isDisabled(component);
        for (ComponentAttribute knownAttribute : attributes) {
            if (!disabled || knownAttribute.getEventNames().length == 0) {
                renderAttributeAndBehaviors(contextcomponentknownAttribute);
            }
        }
    }
    public static String decodeBehaviors(FacesContext context, UIComponent component) {
        if (!(component instanceof ClientBehaviorHolder)) {
            return null;
        }
        ClientBehaviorHolder holder = (ClientBehaviorHolder) component;
        Map<StringList<ClientBehavior>> behaviors = holder.getClientBehaviors();
        if (behaviors == null || behaviors.isEmpty()) {
            return null;
        }
        ExternalContext externalContext = context.getExternalContext();
        Map<StringStringparametersMap = externalContext.getRequestParameterMap();
        String behaviorEvent = parametersMap.get();
        if (behaviorEvent == null) {
            return null;
        }
        List<ClientBehavior> behaviorsForEvent = behaviors.get(behaviorEvent);
        String behaviorSource = parametersMap.get();
        String clientId = component.getClientId(context);
        if (behaviorSource != null && behaviorSource.equals(clientId)) {
            if (behaviorsForEvent != null && !behaviorsForEvent.isEmpty()) {
                for (ClientBehavior behavior : behaviorsForEvent) {
                    behavior.decode(contextcomponent);
                }
                return behaviorEvent;
            }
        }
        return null;
    }
    public static Attributes attributes() {
        return new Attributes();
    }
    public static Attributes attributes(Enum<?>... attrs) {
        Attributes res = new Attributes();
        for (Enum<?> attr : attrs) {
            res.generic(attr.toString(), attr.toString());
        }
        return res;
    }
    public static Attributes attributes(String... attrs) {
        Attributes res = new Attributes();
        for (String attr : attrs) {
            res.generic(attrattr);
        }
        return res;
    }

    
Checks if the argument passed in is empty or not. Object is empty if it is:
- null
- zero-length string
- empty collection
- empty map
- zero-length array

Parameters:
o object to check for emptiness
Returns:
true if the argument is empty, false otherwise
Since:
3.3.2
    private static boolean isEmpty(Object o) {
        if (null == o) {
            return true;
        }
        if (o instanceof String) {
            return (0 == ((Stringo).length());
        }
        if (o instanceof Collection) {
            return ((Collection<?>) o).isEmpty();
        }
        if (o instanceof Map) {
            return ((Map<?, ?>) o).isEmpty();
        }
        if (o.getClass().isArray()) {
            return Array.getLength(o) == 0;
        }
        return false;
    }
    public static void addToScriptHash(Map<StringObjecthashString nameObject value) {
        addToScriptHash(hashnamevaluenullnull);
    }
    public static void addToScriptHash(Map<StringObjecthashString nameObject valueObject defaultValue) {
        addToScriptHash(hashnamevaluedefaultValuenull);
    }

    
Puts value into map under specified key if the value is not empty and not default. Performs optional value wrapping.

Parameters:
hash
name
value
defaultValue
wrapper
Since:
3.3.2
    public static void addToScriptHash(Map<StringObjecthashString nameObject valueObject defaultValue,
            ScriptHashVariableWrapper wrapper) {
        ScriptHashVariableWrapper wrapperOrDefault = wrapper != null ? wrapper : .;
        if (!isEmpty(value) && isAttributeSet(value)) {
            if (defaultValue != null) {
                if (!String.valueOf(defaultValue).equals(value.toString())) {
                    hash.put(namewrapperOrDefault.wrap(value));
                }
            } else {
                if (!(value instanceof Boolean) || ((Booleanvalue).booleanValue()) {
                    hash.put(namewrapperOrDefault.wrap(value));
                }
            }
        }
    }
    public static void addToScriptHash(Map<StringObjecthash, FacesContext facesContext, UIComponent component,
            Attributes attributesScriptHashVariableWrapper wrapper) {
        boolean disabled = isDisabled(component);
        for (ComponentAttribute knownAttribute : attributes) {
            if (!disabled || knownAttribute.getEventNames().length == 0) {
                String attributeName = knownAttribute.getComponentAttributeName();
                addToScriptHash(hashattributeNamegetAttributeAndBehaviorsValue(facesContextcomponentknownAttribute),
                        knownAttribute.getDefaultValue(), wrapper);
            }
        }
    }
    public static String toScriptArgs(Object... objects) {
        if (objects == null) {
            return "";
        }
        int lastNonNullIdx = objects.length - 1;
        for (; 0 <= lastNonNullIdxlastNonNullIdx--) {
            if (!isEmpty(objects[lastNonNullIdx])) {
                break;
            }
        }
        if (lastNonNullIdx < 0) {
            return "";
        }
        if (lastNonNullIdx == 0) {
            return ScriptUtils.toScript(objects[lastNonNullIdx]);
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i <= lastNonNullIdxi++) {
            if (sb.length() > 0) {
                sb.append(",");
            }
            sb.append(ScriptUtils.toScript(objects[i]));
        }
        return sb.toString();
    }
    public static String getResourcePath(FacesContext contextString libraryString resourceName) {
        String path = null;
        if (resourceName != null) {
            ResourceHandler resourceHandler = context.getApplication().getResourceHandler();
            Resource resource = (library != null) ? resourceHandler.createResource(resourceNamelibrary) : resourceHandler
                    .createResource(resourceName);
            if (resource != null) {
                path = resource.getRequestPath();
            }
        }
        return path;
    }
    public static String getResourceURL(String url, FacesContext context) {
        if (null == url) {
            return null;
        }
        Application application = context.getApplication();
        ExternalContext externalContext = context.getExternalContext();
        String value = url;
        if (value.length() == 0 || value.charAt(0) != '/' || !value.startsWith(externalContext.getRequestContextPath())) {
            value = application.getViewHandler().getResourceURL(contextvalue);
        }
        return externalContext.encodeResourceURL(value);
    }
    public static Object getFirstNonEmptyAttribute(String attributeName, UIComponent component) {
        Object attributeValue = component.getAttributes().get(attributeName);
        return !isEmpty(attributeValue) ? attributeValue : null;
    }
    public static Object getFirstNonEmptyAttribute(String attributeName, UIComponent componentA, UIComponent componentB) {
        Object attributeValue = componentA.getAttributes().get(attributeName);
        if (!isEmpty(attributeValue)) {
            return attributeValue;
        }
        attributeValue = componentB.getAttributes().get(attributeName);
        if (!isEmpty(attributeValue)) {
            return attributeValue;
        }
        return null;
    }
    public static Object getFirstNonEmptyAttribute(String attributeName, UIComponent... components) {
        for (UIComponent component : components) {
            Object attributeValue = component.getAttributes().get(attributeName);
            if (!isEmpty(attributeValue)) {
                return attributeValue;
            }
        }
        return null;
    }
    @SuppressWarnings("serial")
    public static final class Attributes extends TreeSet<ComponentAttribute> {
        private ComponentAttribute last;
        public void render(FacesContext context, UIComponent componentthrows IOException {
            renderPassThroughAttributes(contextcomponentthis);
        }
        public Attributes generic(String nameString componentAttributeString... events) {
            ComponentAttribute attribute = createAttribute(namecomponentAttribute);
            attribute.setEventNames(events);
            attribute.setKind(.);
            return this;
        }
        private ComponentAttribute createAttribute(String nameString componentAttribute) {
            ComponentAttribute attribute = new ComponentAttribute(name);
            attribute.setComponentAttributeName(componentAttribute);
            add(attribute);
             = attribute;
            return attribute;
        }
        public Attributes uri(String nameString componentAttribute) {
            ComponentAttribute attribute = createAttribute(namecomponentAttribute);
            attribute.setKind(.);
            return this;
        }
        public Attributes bool(String nameString componentAttribute) {
            ComponentAttribute attribute = createAttribute(namecomponentAttribute);
            attribute.setKind(.);
            return this;
        }
        public Attributes defaultValue(Object value) {
            .setDefaultValue(value);
            return this;
        }
    }
    public static String getBehaviorSourceId(FacesContext facesContext) {
        return facesContext.getExternalContext().getRequestParameterMap().get();
    }
    public static boolean hasFacet(UIComponent componentString facetName) {
        return component.getFacet(facetName) != null && component.getFacet(facetName).isRendered();
    }

    
Tries to evaluate an attribute as ValueExpression. If the attribute doesn't hold ValueExpression or the expression evaluates to null, the value of the attribute is returned.

Parameters:
attribute the name of a component's attribute
component the component
context the context
Returns:
the evaluated ValueExpression for a given attribute or the value of the attribute (in case the attribute isn't ValueExpression or it evaluates to null)
    @SuppressWarnings("unchecked")
    public static <T> T evaluateAttribute(String attribute, UIComponent component, FacesContext context) {
        ValueExpression valueExpression = component.getValueExpression(attribute);
        if (valueExpression != null) {
            T evaluatedValue = (T) valueExpression.getValue(context.getELContext());
            if (evaluatedValue != null) {
                return evaluatedValue;
            }
        }
        return (T) component.getAttributes().get(attribute);
    }
New to GrepCode? Check out our FAQ X