| /******************************************************************************* |
| * Copyright (c) 2005 Oracle Corporation. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Oracle Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jst.pagedesigner.dtmanager.converter.internal; |
| |
| import java.net.URL; |
| |
| import javax.servlet.jsp.el.ELException; |
| import javax.xml.xpath.XPath; |
| import javax.xml.xpath.XPathConstants; |
| import javax.xml.xpath.XPathExpressionException; |
| import javax.xml.xpath.XPathFactory; |
| |
| import org.eclipse.core.runtime.ISafeRunnable; |
| import org.eclipse.core.runtime.SafeRunner; |
| import org.eclipse.jface.resource.ImageDescriptor; |
| import org.eclipse.jst.jsf.common.metadata.Trait; |
| import org.eclipse.jst.jsf.common.metadata.internal.IImageDescriptorProvider; |
| import org.eclipse.jst.jsf.common.metadata.internal.IMetaDataSourceModelProvider; |
| import org.eclipse.jst.jsf.common.metadata.internal.IResourceURLProvider; |
| import org.eclipse.jst.pagedesigner.PDPlugin; |
| import org.eclipse.jst.pagedesigner.converter.IConverterFactory; |
| import org.eclipse.jst.pagedesigner.converter.ITagConverter; |
| import org.eclipse.jst.pagedesigner.dtmanager.DTManager; |
| import org.eclipse.jst.pagedesigner.dtmanager.IDTInfo; |
| import org.eclipse.jst.pagedesigner.dtmanager.converter.ITagConverterDecorator; |
| import org.eclipse.jst.pagedesigner.dtmanager.dtinfo.ResolveAttributeValue; |
| import org.eclipse.jst.pagedesigner.dtmanager.dtinfo.TagDecorateInfo; |
| import org.eclipse.jst.pagedesigner.preview.PageExpressionContext; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| import org.w3c.dom.Text; |
| |
| /** |
| * ITagConverterDecorator implementation for DTTagConverter. |
| * |
| * @author Ian Trimble - Oracle |
| */ |
| public class DTTagConverterDecorator implements ITagConverterDecorator |
| { |
| |
| private static final String DECORATE_INFO_ID_DESIGN = "vpd-decorate-design"; //$NON-NLS-1$ |
| private static final String DECORATE_INFO_ID_PREVIEW = "vpd-decorate-preview"; //$NON-NLS-1$ |
| private static final String MD_PLUGIN_LOCATION = "$metadata-plugin-location$"; //$NON-NLS-1$ |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.jst.pagedesigner.dtmanager.converter.ITagConverterDecorator |
| * #decorate(org.eclipse.jst.pagedesigner.converter.ITagConverter) |
| */ |
| public void decorate(ITagConverter tagConverter) |
| { |
| if (!(tagConverter instanceof DTTagConverter)) |
| { |
| throw new IllegalArgumentException( |
| "ITagConverter argument must be an instance of DTTagConverter"); //$NON-NLS-1$ |
| } |
| DTTagConverter dtTagConverter = (DTTagConverter) tagConverter; |
| |
| if (dtTagConverter.getMode() == IConverterFactory.MODE_DESIGNER) |
| { |
| decorateFromDTInfo(dtTagConverter, DECORATE_INFO_ID_DESIGN); |
| } else if (dtTagConverter.getMode() == IConverterFactory.MODE_PREVIEW) |
| { |
| decorateFromDTInfo(dtTagConverter, DECORATE_INFO_ID_PREVIEW); |
| } |
| |
| if (tagConverter.getResultElement() == null |
| && tagConverter.isVisualByHTML()) |
| { |
| createUnknownTagRepresentation(dtTagConverter); |
| } |
| } |
| |
| /** |
| * Performs decoration of the specified DTTagConverter instance from IDTInfo |
| * (metadata) for the specified (by ID) TagDecorateInfo. |
| * |
| * @param dtTagConverter |
| * DTTagConverter instance. |
| * @param tagDecorateInfoID |
| * ID of the TagDecorateInfo to be located in metadata. |
| */ |
| protected void decorateFromDTInfo(DTTagConverter dtTagConverter, |
| String tagDecorateInfoID) |
| { |
| Element srcElement = dtTagConverter.getHostElement(); |
| DTManager dtManager = DTManager.getInstance(); |
| IDTInfo dtInfo = dtManager.getDTInfo(srcElement); |
| if (dtInfo != null) |
| { |
| TagDecorateInfo tdInfo = dtInfo |
| .getTagDecorateInfo(tagDecorateInfoID); |
| if (tdInfo != null) |
| { |
| dtTagConverter.setMultiLevel(tdInfo.isMultiLevel()); |
| dtTagConverter.setNeedBorderDecorator(tdInfo |
| .isNeedBorderDecorator()); |
| dtTagConverter.setNeedTableDecorator(tdInfo |
| .isNeedTableDecorator()); |
| if (tdInfo.isNonVisual()) |
| { |
| setNonVisual(dtTagConverter, dtInfo, tdInfo |
| .getNonVisualImagePath()); |
| } |
| if (tdInfo.isResolveChildText()) |
| { |
| resolveChildText(dtTagConverter.getResultElement(), dtInfo); |
| } |
| if (tdInfo.isSetNonVisualChildElements()) |
| { |
| setNonVisualChildElements(dtTagConverter, srcElement); |
| } |
| dtTagConverter.setWidget(tdInfo.isWidget()); |
| dtTagConverter.setMinHeight(tdInfo.getMinHeight()); |
| dtTagConverter.setMinWidth(tdInfo.getMinWidth()); |
| ResolveAttributeValue resAttrValue = tdInfo |
| .getResolveAttributeValue(); |
| if (resAttrValue != null) |
| { |
| String attributeName = resAttrValue.getAttributeName(); |
| if (attributeName != null && attributeName.length() > 0) |
| { |
| resolveAttributeValue(dtTagConverter.getHostElement(), |
| dtTagConverter.getResultElement(), |
| attributeName, dtInfo, tagDecorateInfoID); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Creates a visual representation result Element for an unknown tag. |
| * |
| * @param dtTagConverter |
| * DTTagConverter instance. |
| */ |
| protected void createUnknownTagRepresentation(DTTagConverter dtTagConverter) |
| { |
| Element element = dtTagConverter.createElement("span"); //$NON-NLS-1$ |
| element.setAttribute("style", "color:red;font-weight:bold;"); //$NON-NLS-1$ //$NON-NLS-2$ |
| Text text = dtTagConverter |
| .createText("<" + dtTagConverter.getHostElement().getTagName() + "/>"); //$NON-NLS-1$ //$NON-NLS-2$ |
| element.appendChild(text); |
| dtTagConverter.setResultElement(element); |
| dtTagConverter.setWidget(true); |
| } |
| |
| /** |
| * Adds child Elements of the specified source Element to the specified |
| * DTTagConverter instance's collection of non-visual children. |
| * |
| * @param dtTagConverter |
| * DTTagConverter instance. |
| * @param srcElement |
| * Source Element for which child Elements are to be added. |
| */ |
| protected void setNonVisualChildElements(DTTagConverter dtTagConverter, |
| Element srcElement) |
| { |
| NodeList childNodes = srcElement.getChildNodes(); |
| for (int i = 0; i < childNodes.getLength(); i++) |
| { |
| Node curNode = childNodes.item(i); |
| if (curNode.getNodeType() == Node.ELEMENT_NODE) |
| { |
| dtTagConverter.addNonVisualChildElement((Element) curNode); |
| } |
| } |
| } |
| |
| /** |
| * Performs simple EL resolution for the child Text Node of the specified |
| * source Element instance. |
| * |
| * @param srcElement |
| * Source Element for which child Text Node EL resolution is to |
| * be performed. |
| * @param dtInfo |
| * IDTInfo instance. |
| */ |
| protected void resolveChildText(Element srcElement, IDTInfo dtInfo) |
| { |
| if (srcElement != null) |
| { |
| NodeList childNodes = srcElement.getChildNodes(); |
| for (int i = 0; i < childNodes.getLength(); i++) |
| { |
| Node childNode = childNodes.item(i); |
| if (childNode.getNodeType() == Node.TEXT_NODE) |
| { |
| Text textNode = (Text) childNode; |
| String textNodeValue = textNode.getNodeValue(); |
| try |
| { |
| String newTextNodeValue; |
| if (textNodeValue.contains(MD_PLUGIN_LOCATION)) |
| { |
| newTextNodeValue = resolveMDPluginLocation( |
| textNodeValue, dtInfo); |
| } else |
| { |
| newTextNodeValue = (String) PageExpressionContext |
| .getCurrent().evaluateExpression( |
| textNodeValue, String.class, null); |
| } |
| if (newTextNodeValue != null |
| && !textNodeValue.equals(newTextNodeValue)) |
| { |
| textNode.setNodeValue(newTextNodeValue); |
| } |
| } catch (Exception ex) |
| { |
| // ignore - could not resolve, do not change existing |
| // value |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Performs simple EL resolution for the value of the specified attribute of |
| * the specified Element. |
| * |
| * @param srcElement |
| * |
| * @param targetElement |
| * Source Element instance. |
| * @param attributeName |
| * Name of attribute for which the value should be resolved. |
| * @param dtInfo |
| * IDTInfo instance. |
| * @param tagDecorateInfoID |
| */ |
| protected void resolveAttributeValue(Element srcElement, |
| Element targetElement, String attributeName, IDTInfo dtInfo, |
| String tagDecorateInfoID) |
| { |
| if (targetElement != null) |
| { |
| String oldAttributeValue = null; |
| String targetAttributeName = attributeName; |
| // determine if attributeName is XPath and re-target as appropriate |
| if (attributeName.contains("/")) { //$NON-NLS-1$ |
| int lastSlashPos = attributeName.lastIndexOf("/"); //$NON-NLS-1$ |
| String xPathExpression = attributeName.substring(0, |
| lastSlashPos); |
| XPath xPath = XPathFactory.newInstance().newXPath(); |
| try |
| { |
| Object resultObject = xPath.evaluate(xPathExpression, |
| targetElement, XPathConstants.NODE); |
| if (resultObject instanceof Element) |
| { |
| targetElement = (Element) resultObject; |
| targetAttributeName = attributeName |
| .substring(lastSlashPos + 1); |
| } |
| else if (resultObject instanceof Text) |
| { |
| Node parentNode = ((Text)resultObject).getParentNode(); |
| if (parentNode instanceof Element) |
| { |
| parentNode.normalize(); |
| targetAttributeName = IAttributeValueResolver.TEXT_NODE_KEY; |
| oldAttributeValue = ((Text)resultObject).getNodeValue(); |
| } |
| } |
| } |
| catch (XPathExpressionException xee) |
| { |
| // could not evaluate - leave targetElement and |
| // targetAttributeName unchanged |
| } |
| } |
| |
| |
| if (!IAttributeValueResolver.TEXT_NODE_KEY.equals(targetAttributeName)) |
| { |
| oldAttributeValue = targetElement.getAttribute(targetAttributeName); |
| } |
| |
| if (oldAttributeValue != null && oldAttributeValue.length() > 0) |
| { |
| String newAttributeValue; |
| if (oldAttributeValue.contains(MD_PLUGIN_LOCATION)) |
| { |
| newAttributeValue = resolveMDPluginLocation( |
| oldAttributeValue, dtInfo); |
| } |
| else |
| { |
| newAttributeValue = resolveAttributeValue(srcElement, |
| targetElement, targetAttributeName, |
| oldAttributeValue, tagDecorateInfoID); |
| } |
| if (newAttributeValue != null |
| && !oldAttributeValue.equals(newAttributeValue)) |
| { |
| if (IAttributeValueResolver.TEXT_NODE_KEY |
| .equals(targetAttributeName)) |
| { |
| for (int i = targetElement.getChildNodes().getLength()-1; i >= 0; i--) |
| { |
| Node childNode = targetElement.getChildNodes().item(i); |
| if (childNode.getNodeType() == Node.TEXT_NODE) |
| { |
| targetElement.removeChild(childNode); |
| } |
| } |
| targetElement.appendChild(targetElement.getOwnerDocument().createTextNode(newAttributeValue)); |
| } |
| else |
| { |
| targetElement.setAttribute(targetAttributeName, |
| newAttributeValue); |
| } |
| } |
| } |
| } |
| } |
| |
| private String resolveAttributeValue(final Element originalElement, |
| final Element convertedElement, |
| final String convertedAttributeName, final String oldAttributeValue, |
| final String tagDecorateInfoID) |
| { |
| String newValue = null; |
| boolean valueResolved = false; |
| final String[] result = new String[1]; |
| |
| for (final IAttributeValueResolver resolver : AttributeValueResolverRegistryReader |
| .getInstance().getExtensions()) |
| { |
| SafeRunner.run(new ISafeRunnable() |
| { |
| public void handleException(Throwable exception) |
| { |
| PDPlugin |
| .log( |
| "While resolving attribute in converter decorator", exception); //$NON-NLS-1$ |
| } |
| |
| public void run() throws Exception |
| { |
| if (resolver.canResolve(originalElement, |
| convertedElement, convertedAttributeName, oldAttributeValue)) |
| { |
| result[0] = resolver.resolveAttribute( |
| originalElement, convertedElement, |
| convertedAttributeName, oldAttributeValue); |
| } |
| } |
| }); |
| if (result[0] != null) |
| { |
| newValue = result[0]; |
| valueResolved = true; |
| break; |
| } |
| } |
| |
| if (!valueResolved && |
| // maintain backward compatibility: only do this default |
| // behaviour for the preview |
| tagDecorateInfoID.equals(DECORATE_INFO_ID_PREVIEW)) |
| { |
| // fall- through to default case. |
| try |
| { |
| |
| PageExpressionContext current = PageExpressionContext.getCurrent(); |
| if (current != null) |
| { |
| return (String) current |
| .evaluateExpression(oldAttributeValue, String.class, |
| null); |
| } |
| } catch (ELException e) |
| { |
| // ignore. we will just return null since couldn't resolve |
| } |
| } |
| return newValue; |
| } |
| |
| /** |
| * Resolves any instance of MD_PLUGIN_LOCATION in input String. |
| * |
| * @param input |
| * Input String. |
| * @param dtInfo |
| * IDTInfo instance. |
| * @return Input String with any instance of MD_PLUGIN_LOCATION resolved. |
| */ |
| protected String resolveMDPluginLocation(String input, IDTInfo dtInfo) |
| { |
| String output = input; |
| if (input != null && input.contains(MD_PLUGIN_LOCATION)) |
| { |
| int tokenStart = input.indexOf(MD_PLUGIN_LOCATION); |
| int tokenEnd = tokenStart + MD_PLUGIN_LOCATION.length(); |
| String prefix = input.substring(0, tokenStart); |
| String suffix = input.substring(tokenEnd); |
| Trait trait = dtInfo.getTrait(); |
| IMetaDataSourceModelProvider mdSourceModelProvider = trait |
| .getSourceModelProvider(); |
| IResourceURLProvider resourceURLProvider = (IResourceURLProvider) mdSourceModelProvider |
| .getAdapter(IResourceURLProvider.class); |
| URL url = resourceURLProvider.getResourceURL("/META-INF/"); //$NON-NLS-1$ |
| String resolvedToken = url.toExternalForm(); |
| resolvedToken = resolvedToken.substring(0, |
| resolvedToken.length() - 10); |
| output = prefix + resolvedToken + suffix; |
| } |
| return output; |
| } |
| |
| /** |
| * Sets DTTagConverter instance as non-visual as HTML and sets the |
| * ImageDescriptor instance that DTTagConverter will use to return an Image |
| * for rendering. |
| * |
| * @param dtTagConverter |
| * DTTagConverter instance. |
| * @param dtInfo |
| * IDTInfo instance. |
| * @param imagePath |
| * Image path, relative to declaring plug-in. |
| */ |
| protected void setNonVisual(DTTagConverter dtTagConverter, IDTInfo dtInfo, |
| String imagePath) |
| { |
| dtTagConverter.setVisualByHTML(false); |
| if (imagePath != null && imagePath.length() > 0) |
| { |
| Trait trait = dtInfo.getTrait(); |
| IImageDescriptorProvider imgDescProvider = (IImageDescriptorProvider) trait |
| .getSourceModelProvider().getAdapter( |
| IImageDescriptorProvider.class); |
| if (imgDescProvider != null) |
| { |
| ImageDescriptor imageDescriptor = imgDescProvider |
| .getImageDescriptor(imagePath); |
| dtTagConverter.setVisualImageDescriptor(imageDescriptor); |
| } |
| } |
| } |
| |
| } |
