/*
* 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.custom.dojo;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.myfaces.renderkit.html.util.AddResource;
import org.apache.myfaces.renderkit.html.util.AddResourceFactory;
import org.apache.myfaces.shared_tomahawk.renderkit.html.HTML;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.context.ResponseWriter;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.*;
import java.util.Map.Entry;
/**
* Utils class for the dojo infrastructure to ease the component building
* mechanisms note this class uses its own double entries filter due to the fact
* that we can mix and match header and body scripts as needed (we do not want
* to lose portal functionality do we?)
*
* @author Werner Punz (latest modification by $Author: lu4242 $)
* @version $Revision: 697985 $ $Date: 2006-09-08 20:56:28 +0000 (Fri, 08 Sep
* 2006) $
*/
public final class DojoUtils {
private static final String MYFACES_DOJO_DEBUGCONSOLE_ID = "myfaces_Dojo_Debugger";
private static final String DEBUG_CONSOLE_TYPE = "DebugConsole";
private static final String LAYOUT_ALIGN_ATTR = "layoutAlign";
private static final String DISPLAY_CLOSE_ACTION_ATTR = "displayCloseAction";
private static final String RESIZABLE_ATTR = "resizable";
private static final String HAS_SHADOW_ATTR = "hasShadow";
private static final String CONSTRAIN_TO_CONTAINER_ATTR = "constrainToContainer";
private static final String ICON_SRC_ATTR = "iconSrc";
private static final String TITLE_ATTR = "title";
private static final String INCL_TYPE_REQ_KEY = "DOJO_DEVELOPMENT_INCLUDE";
private static final Log log = LogFactory.getLog(DojoUtils.class);
private static final String DOJO_PROVIDE = "dojo.provide:";
private static final String DOJO_REQUIRE = "dojo.require:";
private static final String DOJO_NAMESPACE = "dojo.namespace:";
private static final String DJCONFIG_INITKEY = "/*djconfig init*/";
private static final String BODY_SCRIPT_INFOS_ATTRIBUTE_NAME = "bodyScriptInfos";
private static final String DOJO_FILE_UNCOMPRESSED = "dojo.js.uncompressed.js";
private static final String DOJO_FILE = "dojo.js";
private static final String DJCONFIG_REQ_KEY = "MYFACES_DJCONFIG";
private static final String DOJOEXTENSIONS_NAMESPACE = "dojo.setModulePrefix('extensions', '../dojoextensions.ResourceLoader');";
private DojoUtils() {
// nope
}
/**
* creates a dojoed attribute map upon the given array of attribute names
*
* @param facesContext
* standard faces context used internally
* @param attributeNames
* string array of traversable attribute names
* @param component
* the source component with the values set
* @return a map which resembles the attribute map for further processing
*/
public static Map getAttributeMap(FacesContext facesContext, String[] attributeNames, UIComponent component) {
Log log = null;
Class componentClass = component.getClass();
Map returnMap = new HashMap();
for (int cnt = 0; cnt < attributeNames.length; cnt++) {
try {
String attributeName = attributeNames[cnt];
//the dojo attributes deal with different ids than the rest
if (attributeName.equals("id") || attributeName.equals("widgetId")) {
String calculatedId = DojoUtils.calculateWidgetId(facesContext, component);
returnMap.put("id", calculatedId);
} else {
String attributeCasedName = attributeName.substring(0, 1).toUpperCase() + attributeName.substring(1);
String getForm = "get" + attributeCasedName; // to prevent multiple creating in finding
String isForm = "is" + attributeCasedName; // to prevent multiple creating in finding
Method m = null;
// finding getter in hiearchy: try current class for "get" and "is" form, if NOT found, try superclass
// doesn't use getMethod() to avoid walking whole hiearchy for wrong form in case of "is"
// and getMethod() uses getSuperClass() anyway, so no performance hit this way + ability to invoke protected methods
while ((componentClass != null) && (m == null)) {
m = componentClass.getDeclaredMethod(getForm, null);
if (m == null) {
// try alternative method name for dealing with Booleans
m = componentClass.getDeclaredMethod(isForm, null);
}
if (m == null) {
// load superclass
componentClass = componentClass.getSuperclass(); // null in case of componentClass == Object
}
}
if (m != null) {
Object execRetval = m.invoke(component, null);
if (execRetval != null)
returnMap.put(attributeName, execRetval);
}
}
} catch (Exception e) {
if (log == null)
log = LogFactory.getLog(DojoUtils.class);
// this should not happen but can
log.error("getAttributeMap", e);
}
}
return returnMap;
}
/**
* adds a debug console to the output this is for helping to debug the dojo
* system a debug:true is required for this to work properly it will not be
* set by this method (due to the avoidance of unwanted automatisms causing
* sideefects)
*
* @param facesContext
* @param component
* @return
*/
public static void addDebugConsole(FacesContext facesContext, UIComponent component) throws IOException {
/* check whether we have a debugging flag already set */
if (isInlineScriptSet(facesContext, "/*DOJO DEBUGCONSOLE ON*/"))
return;
AddResource addResource = AddResourceFactory.getInstance(facesContext);
addResource.addInlineScriptAtPosition(facesContext, AddResource.HEADER_BEGIN, "/*DOJO DEBUGCONSOLE ON*/");
ResponseWriter writer = facesContext.getResponseWriter();
// we for now have to break html until the dynamic creation
// isses are resolved, so hold on for this messy code now
// Since this is for debugging purposes only, we can live with it
writer.startElement(HTML.DIV_ELEM, component);
writer.writeAttribute(HTML.ID_ATTR, MYFACES_DOJO_DEBUGCONSOLE_ID, null);
writer.writeAttribute(HTML.STYLE_ATTR, "width: 400px; height: 500px; left: 200px;", null);
writer.endElement(HTML.DIV_ELEM);
Map attributeMap = new HashMap();
attributeMap.put(TITLE_ATTR, "MyFaces Dojo Debug console");
attributeMap.put(ICON_SRC_ATTR, "images/flatScreen.gif");
attributeMap.put(CONSTRAIN_TO_CONTAINER_ATTR, new Integer(1));
attributeMap.put(HAS_SHADOW_ATTR, new Boolean(true));
attributeMap.put(RESIZABLE_ATTR, new Boolean(true));
attributeMap.put(DISPLAY_CLOSE_ACTION_ATTR, new Boolean(true));
attributeMap.put(LAYOUT_ALIGN_ATTR, "client");
renderWidgetInitializationCode(writer, component, DEBUG_CONSOLE_TYPE, attributeMap, MYFACES_DOJO_DEBUGCONSOLE_ID, true);
}
/**
* check if dojo is going to be used
*/
public static boolean isDojoInitialized(FacesContext facesContext)
{
return isInlineScriptCheck(facesContext, DJCONFIG_INITKEY);
}
public static void addMainInclude(FacesContext facesContext, UIComponent component, String javascriptLocation, DojoConfig config) throws IOException {
AddResource addResource = AddResourceFactory.getInstance(facesContext);
/*
* var djConfig = { isDebug: false }; TODO add a saner handling of
* collecting all djconfig data and then merging it
*/
if (!isInlineScriptSet(facesContext, DJCONFIG_INITKEY)) {
addResource.addInlineScriptAtPosition(facesContext, AddResource.HEADER_BEGIN, DJCONFIG_INITKEY);
addResource.addInlineScriptAtPosition(facesContext, AddResource.HEADER_BEGIN, config.toString());
String dojofile = ((getExpanded(facesContext) != null) && getExpanded(facesContext).booleanValue()) ? DOJO_FILE_UNCOMPRESSED : DOJO_FILE;
if (javascriptLocation != null) {
addResource.addJavaScriptAtPosition(facesContext, AddResource.HEADER_BEGIN, javascriptLocation + dojofile);
} else {
/*
* ResponseWriter writer = facesContext.getResponseWriter();
* writer.startElement(HTML.SCRIPT_ELEM,component);
*
* MyFacesResourceHandler handler = new
* MyFacesResourceHandler(DojoResourceLoader.class, dojofile);
* String uri = handler.getResourceUri(facesContext); uri =
* uri.replaceAll("dojo\\.js\\;jsessionid(.)*\\\"","dojo.js");
* writer.writeAttribute(HTML.SRC_ATTR, uri, null);
*
* writer.endElement(HTML.SCRIPT_ELEM);
* addResource.addJavaScriptAtPosition(facesContext,
* AddResource.HEADER_BEGIN, DojoResourceLoader.class,
* dojofile);
*/
addResource.addJavaScriptAtPositionPlain(facesContext, AddResource.HEADER_BEGIN, DojoResourceLoader.class, dojofile);
}
addResource.addInlineScriptAtPosition(facesContext, AddResource.HEADER_BEGIN, DOJOEXTENSIONS_NAMESPACE);
}
}
/**
* adds a new namespace location to the mix
*
* @param facesContext
* the faces context which is used internally
* @param component
* the affected component
* @param namespace
* the namespace which has to be applied
* @param location
* the script location
* @throws IOException
* @link http://blog.dojotoolkit.org/2006/01/11/putting-your-code-outside-of-the-dojo-source-tree
*/
public static void addNamespace(FacesContext facesContext, UIComponent component, String namespace, String location) throws IOException {
if (isInlineScriptSet(facesContext, DOJO_NAMESPACE + namespace))
return;
String namespaceStr = createNamespaceScript(namespace, location);
writeInlineScript(facesContext, component, namespaceStr);
}
/**
* adds a dojo provide to the current list of definitions within the header
*
* @param context
* the faces context for accessing the resources internally
* @param provided
* the package with the class provided by this implementation
* @see <a
* href="http://dojotoolkit.org/docs/fast_widget_authoring.html">Dojo-Widget-Authoring</a>
* for an example on this
*/
public static void addProvide(FacesContext context, String provided) {
if (isInlineScriptSet(context, DOJO_PROVIDE + provided))
return;
AddResource addResource = AddResourceFactory.getInstance(context);
String providedBuilder = createDojoProvideScript(provided);
addResource.addInlineScriptAtPosition(context, AddResource.HEADER_BEGIN, providedBuilder);
}
/**
* adds a dojo provide
*
* @param facesContext
* @param component
* @param provided
* @throws IOException
*/
public static void addProvide(FacesContext facesContext, UIComponent component, String provided) throws IOException {
if (isInlineScriptSet(facesContext, DOJO_PROVIDE + provided))
return;
String providedBuilder = createDojoProvideScript(provided);
writeInlineScript(facesContext, component, providedBuilder);
}
/**
* convenience method for easier requires handling
* @param facesContext standard faces context
* @param component the component
* @param requires an array of requires which is rendered into single dojo.require statements
* @throws IOException
*/
public static void addRequire(FacesContext facesContext, UIComponent component, String[] requires) throws IOException {
for (int cnt = 0; cnt < requires.length; cnt++)
addRequire(facesContext, component, requires[cnt]);
}
/**
* adds a dojo require include to our mix of stuff used
*
* @param facesContext
* @param required
*/
public static void addRequire(FacesContext facesContext, UIComponent component, String required) throws IOException {
if (isInlineScriptSet(facesContext, DOJO_REQUIRE + required))
return;
String requireAsScript = createDojoRequireString(required);
writeInlineScript(facesContext, component, requireAsScript);
}
/**
* creates a debug statement for the debug console
*
* @param stmnt
* the debug message displayed by the debug console
* @return javaScriptcode String
*/
public static String createDebugStatement(String stmnt) {
return "dojo.debug(\"" + stmnt + "\");\n";
}
/**
* creates a debug statement and a corresponding value for the debug console
*
* @param stmnt
* the debug message displayed and given value by the debug
* console
* @return javaScriptcode String
*/
public static String createDebugStatement(String stmnt, String value) {
return "dojo.debug(\"" + stmnt + ":\");dojo.debug(" + value + ");\n";
}
/**
* helper method which does the proper dojo provide script creation
*
* @param provided
* the provided class name
* @return dojoProvide String
*/
public static String createDojoProvideScript(String provided) {
StringBuffer providedBuilder = new StringBuffer(32);
providedBuilder.append("dojo.provide('");
providedBuilder.append(provided.trim());
providedBuilder.append("');");
return providedBuilder.toString();
}
/**
* helper method for the proper dojo require script creation
*
* @param required
* the creation package for the require functionality
* @return dojoRequire String
*/
public static String createDojoRequireString(String required) {
StringBuffer requiredBuilder = new StringBuffer(32);
requiredBuilder.append("dojo.require('");
requiredBuilder.append(required.trim());
requiredBuilder.append("');");
return requiredBuilder.toString();
}
/**
* Request singleton getter method for the djConfig object
*
* @param context
* @return
*/
public static DojoConfig getDjConfigInstance(FacesContext context) {
// we wont have a need for a synchronized here, since
// we are in a single request cycle anyway
// but take care if you use the djconfig in multiple threads!
//DojoConfig djConfig = (DojoConfig) ((HttpServletRequest) context.getExternalContext().getRequest()).getAttribute(DJCONFIG_REQ_KEY);
DojoConfig djConfig = (DojoConfig) (context.getExternalContext().getRequestMap()).get(DJCONFIG_REQ_KEY);
if (djConfig == null) {
djConfig = new DojoConfig();
//((HttpServletRequest) context.getExternalContext().getRequest()).setAttribute(DJCONFIG_REQ_KEY, djConfig);
context.getExternalContext().getRequestMap().put(DJCONFIG_REQ_KEY, djConfig);
}
return djConfig;
}
/**
* getter for the expanded flat
*
* @param facesContext
* @return
*/
public static Boolean getExpanded(FacesContext facesContext) {
// either the development attribute set or a special request key
//HttpServletRequest request = (HttpServletRequest) facesContext.getExternalContext().getRequest();
//Boolean devStatus = (Boolean) request.getAttribute(INCL_TYPE_REQ_KEY);
Boolean devStatus = (Boolean) facesContext.getExternalContext().getRequestMap().get(INCL_TYPE_REQ_KEY);
DojoConfig config = getDjConfigInstance(facesContext);
if (devStatus == null)
devStatus = new Boolean(false);
devStatus = new Boolean(devStatus.booleanValue() || (config.getDevelopment() != null && config.getDevelopment().booleanValue()));
return devStatus;
}
/**
* Inline script set
*
* @param context
* standard faces context
* @param inlineScript
* key to the inline script
* @return true if the inline script already is set
*/
public static boolean isInlineScriptSet(FacesContext context, String inlineScript) {
// TODO move this non neutral code into the resource handler
//HttpServletRequest request = (HttpServletRequest) context.getExternalContext().getRequest();
Set set = getBodyScriptInfos(context.getExternalContext().getRequestMap());
if (!set.contains(inlineScript)) {
set.add(inlineScript);
return false;
}
return true;
}
/**
* check if the script with the given inlineScript-name has been added
*/
public static boolean isInlineScriptCheck(FacesContext context, String inlineScript)
{
// TODO move this non neutral code into the resource handler
//HttpServletRequest request = (HttpServletRequest) context.getExternalContext().getRequest();
Set set = getBodyScriptInfos(context.getExternalContext().getRequestMap());
return set.contains(inlineScript);
}
/**
* please, instead of using standard dojo taglib mechanisms use this code
* for initialisation it will render a clean and proper javascript
* initialisation instead. There are issues with ADF and the dojo taglib
* mechanisms and also (Alex Russel wont like to hear this) the dojo taglib
* initialisation fails on W3C validations. returns the name of the
* javascript var for further processing
*
* @param facesContext
* standard faces context
* @param component
* standard component
* @param dojoType
* the dojo type of this component
* @param paramMap
*/
public static String renderWidgetInitializationCode(FacesContext facesContext, UIComponent component, String dojoType, Map paramMap) throws IOException {
ResponseWriter writer = facesContext.getResponseWriter();
String clientId = component.getClientId(facesContext);
return renderWidgetInitializationCode(writer, component, dojoType, paramMap, clientId, true);
}
/**
* convenience method to render the widget init code automatically
* for a given component and a set of attribute names
*
* @param facesContext
* @param component
* @param dojoType
* @param attributeNames
* @return
* @throws IOException
*/
public static String renderWidgetInitializationCode(FacesContext facesContext, UIComponent component, String dojoType, String[] attributeNames)
throws IOException {
Map paramMap = DojoUtils.getAttributeMap(facesContext, attributeNames, component);
return renderWidgetInitializationCode(facesContext, component, dojoType, paramMap);
}
/**
* same for a given neutral id...
*
* @param dojoType
* @param paramMap
* @param clientId
* the referencing id which the widget has to render to (note the
* id is enforced the uicomponent does nothing in this case!!!!)
* @param refId
* if true the refid is set in the dojo javascript init code if
* false no ref is set the false often is needed for containers
* which dynamically generated widgets with no referencing div
* @return a string with the name of the javascript variable
*/
public static String renderWidgetInitializationCode(ResponseWriter writer, UIComponent component, String dojoType, Map paramMap, String clientId,
boolean refId) throws IOException {
writer.startElement(HTML.SCRIPT_ELEM, component);
writer.writeAttribute(HTML.TYPE_ATTR, HTML.SCRIPT_TYPE_TEXT_JAVASCRIPT, null);
String javascriptVar = (String) paramMap.get("widgetVar");
if (StringUtils.isBlank(javascriptVar))
javascriptVar = calculateWidgetVarName(clientId);
Iterator it = paramMap.entrySet().iterator();
writer.write("var ");
writer.write(javascriptVar);
writer.write(" = ");
writer.write("dojo.widget.createWidget(\"");
writer.write(dojoType);
writer.write("\",");
writer.write("{");
boolean first = true;
while (it.hasNext()) {
Entry entry = (Entry) it.next();
Object value = entry.getValue();
if (value != null) {
if (!first)
writer.write(",");
writer.write(entry.getKey().toString());
writer.write(":"); // only real string values should be within
// ambersants, dojo req
boolean isString = value instanceof String;
if (isString)
{
if( value.equals("true")
|| value.equals("false") )
isString = false;
}
if (isString)
writer.write("'");
writer.write(value.toString());
if (isString)
writer.write("'");
first = false;
}
}
writer.write("}");
if (refId) {
writer.write(",dojo.byId('");
writer.write(clientId);
writer.write("')");
}
writer.write(");");
writer.endElement(HTML.SCRIPT_ELEM);
return javascriptVar;
}
/**
* helper method to centralize the widget variable name calculation for our
* dojo javascript widget init code
*
* @param clientId
* the client id upon which the var name has to be generated
* @return the javascript widget var name for the given client id
*/
public static String calculateWidgetVarName(String clientId) {
return clientId.replaceAll("\\:", "_") + "_dojoControl";
}
/**
*
* @return
*/
public static String calculateWidgetId(FacesContext context, UIComponent widget) {
String widgetVarName = "";
if (widget instanceof DojoWidget) {
widgetVarName = ((DojoWidget) widget).getWidgetId();
}
if (StringUtils.isBlank(widgetVarName)) {
widgetVarName = calculateWidgetVarName(widget.getClientId(context));
}
return widgetVarName;
}
/**
*
* @return
*/
public static String calculateWidgetVarName(FacesContext context, UIComponent widget) {
String widgetVarName = "";
if (widget instanceof DojoWidget) {
widgetVarName = ((DojoWidget) widget).getWidgetVar();
}
if (StringUtils.isBlank(widgetVarName)) {
widgetVarName = calculateWidgetVarName(widget.getClientId(context));
}
return widgetVarName;
}
/**
* helper to merge in an external dojo config instance the merge algorithm
* is that an existing entry is overwritten if a new config entry is set
* make sure that this is not called too often due to the fact that we do
* heavy reflection in here
*
* @param context
* @param config
*/
public static void mergeExternalDjConfig(FacesContext context, DojoConfig config) {
// we now do the same as beanutils, but for dependency reasons we code
// it
DojoConfig configSingleton = getDjConfigInstance(context);
Class dcConfigClass = DojoConfig.class;
Method[] djConfigFieldArr = dcConfigClass.getMethods();
for (int cnt = 0; cnt < djConfigFieldArr.length; cnt++) {
try {
Method configPropertyField = djConfigFieldArr[cnt];
String methodCore = null;
if ((!configPropertyField.getName().startsWith("getClass") && configPropertyField.getName().startsWith("get"))
|| configPropertyField.getName().startsWith("is"))
methodCore = (configPropertyField.getName().startsWith("get")) ? configPropertyField.getName().substring(3) : configPropertyField.getName()
.substring(2);
if (methodCore != null) {
Object val = configPropertyField.invoke(config, null);
if (val != null) {
Class[] setterParams = new Class[1];
setterParams[0] = val.getClass();
Method setMethod = dcConfigClass.getMethod("set" + methodCore, setterParams);
if (setMethod != null) {
Object[] setterArgs = new Object[1];
setterArgs[0] = val;
setMethod.invoke(configSingleton, setterArgs);
}
}
}
} catch (IllegalArgumentException e) {
log.error(e);
} catch (SecurityException e) {
log.error(e);
} catch (IllegalAccessException e) {
log.error(e);
} catch (InvocationTargetException e) {
log.error(e);
} catch (NoSuchMethodException e) {
log.error(e);
}
}
}
/**
* if this flag is set to true somewhere before the rendering, the expanded
* version is loaded otherwise the nonexpanded version is loaded
*
* @param facesContext
* context because we again have a full request singleton here
* @param expanded
* if set to true the expanded version of the dojo scripts are
* loaded otherwise the non expanded ones are loaded
*/
public static void setExpanded(FacesContext facesContext, Boolean expanded) {
//HttpServletRequest request = (HttpServletRequest) facesContext.getExternalContext().getRequest();
//request.setAttribute(INCL_TYPE_REQ_KEY, expanded);
facesContext.getExternalContext().getRequestMap().put(INCL_TYPE_REQ_KEY, expanded);
}
/**
* helper to write out debug statements this is only a convenience method to
* reduce the code bloat
*
* @param writer
* @param stmnt
* @return
* @throws IOException
*/
public static void writeDebugStatement(ResponseWriter writer, String stmnt) throws IOException {
stmnt = createDebugStatement(stmnt);
writer.write(stmnt);
}
/**
* dojo namespace definition method allows the definition of a new namespace
* within the parameters of the dojo namespacing system
*
* @param namespace
* the dojo namespace
* @param location
* the exaclt script location (can be a relative location)
*
* @return the namespace script which has to be printed / executed
*/
private static String createNamespaceScript(String namespace, String location) {
StringBuffer namespaceBuilder = new StringBuffer(32);
namespaceBuilder.append("dojo.hostenv.setModulePrefix('");
namespaceBuilder.append(namespace);
namespaceBuilder.append("','");
namespaceBuilder.append(location);
namespaceBuilder.append("');");
String namespaceStr = namespaceBuilder.toString();
return namespaceStr;
}
/*
private static Set getBodyScriptInfos(HttpServletRequest request) {
Set set = (Set) request.getAttribute(BODY_SCRIPT_INFOS_ATTRIBUTE_NAME);
if (set == null) {
set = new TreeSet();
request.setAttribute(BODY_SCRIPT_INFOS_ATTRIBUTE_NAME, set);
}
return set;
}*/
private static Set getBodyScriptInfos(Map requestMap) {
Set set = (Set) requestMap.get(BODY_SCRIPT_INFOS_ATTRIBUTE_NAME);
if (set == null) {
set = new TreeSet();
requestMap.put(BODY_SCRIPT_INFOS_ATTRIBUTE_NAME, set);
}
return set;
}
/**
* helper to write an inline javascript at the exact resource location of
* the call
*
* @param facesContext
* @param component
* @param script
* @throws IOException
*/
private static void writeInlineScript(FacesContext facesContext, UIComponent component, String script) throws IOException {
ResponseWriter writer = facesContext.getResponseWriter();
writer.startElement(HTML.SCRIPT_ELEM, component);
writer.writeAttribute(HTML.TYPE_ATTR, HTML.SCRIPT_TYPE_TEXT_JAVASCRIPT, null);
writer.write(script);
writer.endElement(HTML.SCRIPT_ELEM);
}
}