public RenderKitImpl() 
{
        FacesContext context = FacesContext.getCurrentInstance();
        webConfig = WebConfiguration.getInstance(context.getExternalContext());
}

 public  void addClientBehaviorRenderer(String behaviorRendererType,
    ClientBehaviorRenderer behaviorRenderer) 
{
        Util.notNull("behaviorRendererType", behaviorRendererType);
        Util.notNull("behaviorRenderer", behaviorRenderer);
        if (LOGGER.isLoggable(Level.FINE) && behaviorRenderers.containsKey(behaviorRendererType)) {
            LOGGER.log(Level.FINE,
                       "behaviorRendererType {0} has already been registered.  Replacing existing behavior renderer class type {1} with {2}.",
                       new Object[] { behaviorRendererType, behaviorRenderers.get(behaviorRendererType).getClass().getName(), behaviorRenderer.getClass().getName() });
        }
        behaviorRenderers.put(behaviorRendererType, behaviorRenderer);
}

 public  void addRenderer(String family,
    String rendererType,
    Renderer renderer) 
{
        Util.notNull("family", family);
        Util.notNull("rendererType", rendererType);
        Util.notNull("renderer", renderer);
        HashMap< String,Renderer > renderers = rendererFamilies.get(family);
        if (renderers == null) {
            renderers = new HashMap< String,Renderer >();
            rendererFamilies.put(family, renderers);
        }
        if (LOGGER.isLoggable(Level.FINE) && renderers.containsKey(rendererType)) {
            LOGGER.log(Level.FINE,
                       "rendererType {0} has already been registered for family {1}.  Replacing existing renderer class type {2} with {3}.",
                       new Object[] { rendererType, family, renderers.get(rendererType).getClass().getName(), renderer.getClass().getName() });
        }
        renderers.put(rendererType, renderer);
}

 public ResponseStream createResponseStream(OutputStream out) 
{
        final OutputStream output = out;
        return new ResponseStream() {
            public void write(int b) throws IOException {
                output.write(b);
            }
            public void write(byte b[]) throws IOException {
                output.write(b);
            }
            public void write(byte b[], int off, int len) throws IOException {
                output.write(b, off, len);
            }
            public void flush() throws IOException {
                output.flush();
            }
            public void close() throws IOException {
                output.close();
            }
        };
}

 public ResponseWriter createResponseWriter(Writer writer,
    String desiredContentTypeList,
    String characterEncoding) 
{
        if (writer == null) {
            return null;
        }
        String contentType = null;
        boolean contentTypeNullFromResponse = false;
        FacesContext context = FacesContext.getCurrentInstance();
        // Step 1: Check the content type passed into this method 
        if (null != desiredContentTypeList) {
            contentType = findMatch(
                 desiredContentTypeList,
                 SUPPORTED_CONTENT_TYPES_ARRAY);
        }
        // Step 2: Check the response content type
        if (null == desiredContentTypeList) {
            desiredContentTypeList =
                 context.getExternalContext().getResponseContentType();
            if (null != desiredContentTypeList) {
                contentType = findMatch(
                     desiredContentTypeList,
                     SUPPORTED_CONTENT_TYPES_ARRAY);
                if (null == contentType) {
                    contentTypeNullFromResponse = true;
                }
            }
        }
        // Step 3: Check the Accept Header content type
        // Evaluate the accept header in accordance with HTTP specification - 
        // Section 14.1
        // Preconditions for this (1 or 2):
        //  1. content type was not specified to begin with
        //  2. an unsupported content type was retrieved from the response 
        if (null == desiredContentTypeList || contentTypeNullFromResponse) {
            String[] typeArray =
                 context.getExternalContext().getRequestHeaderValuesMap().get("Accept");
            if (typeArray.length  > 0) {
                StringBuffer buff = new StringBuffer();
                buff.append(typeArray[0]);
                for (int i = 1, len = typeArray.length; i <  len; i++) {
                    buff.append(',');
                    buff.append(typeArray[i]);
                }
                desiredContentTypeList = buff.toString();
            }
            if (null != desiredContentTypeList) {
                desiredContentTypeList =
                      RenderKitUtils.determineContentType(desiredContentTypeList,
                                                          SUPPORTED_CONTENT_TYPES,
                                                          ((preferXhtml())
                                                              ? RIConstants.XHTML_CONTENT_TYPE
                                                              : null));
                if (null != desiredContentTypeList) {
                    contentType = findMatch(
                         desiredContentTypeList,
                         SUPPORTED_CONTENT_TYPES_ARRAY);
                }
            }
        }
        // Step 4: Default to text/html
        if (contentType == null) {
            if (null == desiredContentTypeList) {
                contentType = getDefaultContentType();
            } else {
                String[] desiredContentTypes =
                      contentTypeSplit(desiredContentTypeList);
                for (String desiredContentType : desiredContentTypes) {
                    if (RIConstants.ALL_MEDIA.equals(desiredContentType.trim())) {
                        contentType = getDefaultContentType();
                    }
                }
            }
        }
        if (null == contentType) {
            throw new IllegalArgumentException(MessageUtils.getExceptionMessageString(
                 MessageUtils.CONTENT_TYPE_ERROR_MESSAGE_ID));
        }
        if (characterEncoding == null) {
            characterEncoding = RIConstants.CHAR_ENCODING;
        }
        boolean scriptHiding = webConfig.isOptionEnabled(EnableJSStyleHiding);
        boolean scriptInAttributes = webConfig.isOptionEnabled( EnableScriptInAttributeValue);
        WebConfiguration.DisableUnicodeEscaping escaping =
              WebConfiguration.DisableUnicodeEscaping.getByValue(
                    webConfig.getOptionValue(DisableUnicodeEscaping));
        boolean isPartial = context.getPartialViewContext().isAjaxRequest();
        return new HtmlResponseWriter(writer,
                                      contentType,
                                      characterEncoding,
                                      scriptHiding,
                                      scriptInAttributes,
                                      escaping,
                                      isPartial);
}

 public ClientBehaviorRenderer getClientBehaviorRenderer(String behaviorRendererType) 
{
        Util.notNull("behaviorRendererType", behaviorRendererType);
        return ((behaviorRenderers != null) ? behaviorRenderers.get(behaviorRendererType) : null);
}

 public Iterator<String> getComponentFamilies() 
{
        return rendererFamilies.keySet().iterator();
}

 public Renderer getRenderer(String family,
    String rendererType) 
{
        Util.notNull("family", family);
        Util.notNull("rendererType", rendererType);
        assert(rendererFamilies != null);
        HashMap< String,Renderer > renderers = rendererFamilies.get(family);
        return ((renderers != null) ? renderers.get(rendererType) : null);
}

 public Iterator<String> getRendererTypes(String componentFamily) 
{
        Map< String,Renderer > family = rendererFamilies.get(componentFamily);
        if (family != null) {
            return family.keySet().iterator();
        } else {
            Set< String > empty = Collections.emptySet();
            return empty.iterator();
        }
}

 public synchronized ResponseStateManager getResponseStateManager() 
{
        if (responseStateManager == null) {
            responseStateManager = new ResponseStateManagerImpl();
        }
        return responseStateManager;
}