| /******************************************************************************* |
| * Copyright (c) 2006 Sybase, Inc. and others. |
| * |
| * 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: |
| * Sybase, Inc. - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jst.pagedesigner.editors.palette.impl; |
| |
| import java.io.InputStream; |
| import java.net.URL; |
| import java.util.Arrays; |
| import java.util.Comparator; |
| import java.util.HashMap; |
| import java.util.Map; |
| |
| import javax.xml.parsers.DocumentBuilder; |
| import javax.xml.parsers.DocumentBuilderFactory; |
| |
| import org.eclipse.core.runtime.IConfigurationElement; |
| import org.eclipse.core.runtime.IExtensionPoint; |
| import org.eclipse.core.runtime.IExtensionRegistry; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.jface.resource.ImageDescriptor; |
| import org.eclipse.jst.jsp.core.internal.contentmodel.tld.provisional.TLDDocument; |
| import org.eclipse.jst.jsp.core.internal.contentmodel.tld.provisional.TLDElementDeclaration; |
| import org.eclipse.jst.pagedesigner.IHTMLConstants; |
| import org.eclipse.jst.pagedesigner.IJMTConstants; |
| import org.eclipse.jst.pagedesigner.PDPlugin; |
| import org.eclipse.jst.pagedesigner.common.utils.ResourceUtils; |
| import org.eclipse.jst.pagedesigner.common.utils.StringUtil; |
| import org.eclipse.jst.pagedesigner.editors.palette.IPaletteConstants; |
| import org.eclipse.jst.pagedesigner.editors.palette.IPaletteItemCategory; |
| import org.eclipse.jst.pagedesigner.editors.palette.IPaletteItemDescriptor; |
| import org.eclipse.jst.pagedesigner.editors.palette.IPaletteItemManager; |
| import org.eclipse.wst.html.core.internal.contentmodel.HTMLElementDeclaration; |
| import org.eclipse.wst.xml.core.internal.contentmodel.CMDocument; |
| import org.eclipse.wst.xml.core.internal.contentmodel.CMElementDeclaration; |
| import org.eclipse.wst.xml.core.internal.contentmodel.CMNamedNodeMap; |
| import org.osgi.framework.Bundle; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.NodeList; |
| |
| /** |
| * Helper class. |
| * |
| * @author mengbo |
| */ |
| public class PaletteHelper { |
| public static void configPaletteItemsByTLD(IPaletteItemManager manager, |
| TLDDocument tldDoc) { |
| String tldURI = tldDoc.getUri(); |
| if (tldURI == null) { |
| return; |
| } |
| IPaletteItemCategory category = manager.getCategoryByURI(tldURI); |
| if (category == null) { |
| category = manager.createCategory(tldURI); |
| } |
| // category is in what user selected in Component Support Property Page |
| // ,so set state to be Visible |
| category.setVisible(true); |
| |
| String prefix = category.getDefaultPrefix(); |
| if (prefix == null || prefix.length() == 0) { |
| category.setDefaultPrefix(tldDoc.getShortname()); |
| } |
| String label = category.getLabel(); |
| if (label == null || label.length() == 0) { |
| category.setLabel(tldDoc.getDisplayName()); |
| } |
| loadFromCMDocument(category, tldDoc); |
| } |
| |
| /** |
| * basically, this method will read information from the CMDocument. It will |
| * check the existing items in the registry. If the corresponding tag is not |
| * in palette manager, then it will create one, and mark the newly created |
| * item as "expert". Otherwise, it will check whether the tld contains more |
| * information than the palette manager, and adding those information to it |
| * (such as description, icons for tags) |
| * |
| * @param manager |
| * @param tldDoc |
| */ |
| public static void loadFromCMDocument(IPaletteItemCategory category, |
| CMDocument cmdoc) { |
| CMNamedNodeMap nodeMap = cmdoc.getElements(); |
| for (int i = 0, size = nodeMap.getLength(); i < size; i++) { |
| CMElementDeclaration eledecl = (CMElementDeclaration) nodeMap |
| .item(i); |
| String tagName = eledecl.getElementName(); |
| IPaletteItemDescriptor item; |
| if (tagName.equalsIgnoreCase(IHTMLConstants.TAG_INPUT)) { |
| StringBuffer name = new StringBuffer(category.getURI()); |
| name.append(":").append(tagName).append(":").append(tagName); |
| item = category.getItemByID(name.toString()); |
| } else { |
| item = category.getItemByTagName(tagName); |
| } |
| if (item == null) { |
| item = category.createItem(tagName); |
| StringBuffer name = new StringBuffer(category.getURI()); |
| name.append(":").append(tagName).append(":").append(tagName); |
| item.setId(name.toString()); |
| // for newly created item, set expert to true. |
| item.setVisible(true); |
| item.setURI(category.getURI()); |
| if (category.getURI().equals(IJMTConstants.URI_HTML))//$NON-NLS-1$ |
| { |
| item.setVisible(false); |
| } |
| } |
| configItem(item, eledecl); |
| item.setDefaultPrefix(category.getDefaultPrefix()); |
| } |
| } |
| |
| /** |
| * @param item |
| * @param eledecl |
| */ |
| private static void configItem(IPaletteItemDescriptor item, |
| CMElementDeclaration eledecl) { |
| if (eledecl instanceof HTMLElementDeclaration) { |
| configHTMLItem(item, (HTMLElementDeclaration) eledecl); |
| } else if (eledecl instanceof TLDElementDeclaration) { |
| configTLDItem(item, (TLDElementDeclaration) eledecl); |
| } |
| } |
| |
| /** |
| * @param item |
| * @param declaration |
| */ |
| private static void configTLDItem(IPaletteItemDescriptor item, |
| TLDElementDeclaration declaration) { |
| String olddesc = item.getDescription(); |
| if (olddesc == null || olddesc.length() == 0) { |
| String des = declaration.getDescription(); |
| des = StringUtil.filterConvertString(des); |
| item.setDescription(des); |
| } |
| } |
| |
| /** |
| * @param item |
| * @param declaration |
| */ |
| private static void configHTMLItem(IPaletteItemDescriptor item, |
| HTMLElementDeclaration declaration) { |
| } |
| |
| public static void readConfigFromPlugin(IPaletteItemManager manager) { |
| IExtensionRegistry extensionRegistry = Platform.getExtensionRegistry(); |
| IExtensionPoint point = extensionRegistry |
| .getExtensionPoint(PDPlugin.getPluginId(), |
| IJMTConstants.EXTENSION_POINT_PALETTEITEMCONFIG); |
| if (point != null) { |
| IConfigurationElement[] elements = point.getConfigurationElements(); |
| Arrays.sort(elements, new Comparator() { |
| /* |
| * (non-Javadoc) |
| * |
| * @see java.util.Comparator#compare(java.lang.Object, |
| * java.lang.Object) |
| */ |
| public int compare(Object o1, Object o2) { |
| IConfigurationElement d1 = (IConfigurationElement) o1; |
| IConfigurationElement d2 = (IConfigurationElement) o2; |
| return d1 |
| .getAttribute( |
| IJMTConstants.ATTRIBUTE_INDEX_PALETTEITEMCONFIG) |
| .compareToIgnoreCase( |
| d2 |
| .getAttribute(IJMTConstants.ATTRIBUTE_INDEX_PALETTEITEMCONFIG)); |
| } |
| }); |
| for (int i = 0, size = elements.length; i < size; i++) { |
| IConfigurationElement ce = elements[i]; |
| String id = ce.getDeclaringExtension().getNamespaceIdentifier(); |
| Bundle bundle = Platform.getBundle(id); |
| String path = ce |
| .getAttribute(IJMTConstants.ATTRIBUTE_PATH_PALETTEITEMCONFIG); |
| readConfig(manager, bundle, path); |
| } |
| } |
| |
| } |
| |
| static void readConfig(IPaletteItemManager manager, Bundle bundle, |
| String path) { |
| try { |
| if (bundle.getEntry(path) == null) { |
| return; |
| } |
| InputStream stream = bundle.getEntry(path).openStream(); |
| DocumentBuilder builder = DocumentBuilderFactory.newInstance() |
| .newDocumentBuilder(); |
| Document doc = builder.parse(stream); |
| ResourceUtils.ensureClosed(stream); |
| |
| NodeList categories = doc |
| .getElementsByTagName(IPaletteConstants.CATEGORY_TAG); |
| for (int i = 0, ilength = categories.getLength(); i < ilength; i++) { |
| Element cat = (Element) categories.item(i); |
| String prefix = cat.getAttribute(IPaletteConstants.ICONPREFIX); |
| String uri = cat.getAttribute(IPaletteConstants.URI); |
| String catlabel = cat.getAttribute(IPaletteConstants.LABEL); |
| IPaletteItemCategory category = manager.findOrCreateCategory( |
| uri, catlabel); |
| String jsfComponentCategory = cat |
| .getAttribute(IPaletteConstants.JSFCOMPONENTCATEGORY); |
| boolean bJSF = Boolean.TRUE.toString().equalsIgnoreCase( |
| jsfComponentCategory); |
| if (bJSF) { |
| // avoid override. maybe someother place has already set it |
| // to be true. |
| category.setJSFComponentCategory(bJSF); |
| } |
| |
| NodeList items = cat |
| .getElementsByTagName(IPaletteConstants.ITEM_TAG); |
| |
| for (int j = 0, jlength = items.getLength(); j < jlength; j++) { |
| Element item = (Element) items.item(j); |
| PaletteItemDescriptor descriptor = new PaletteItemDescriptor(); |
| descriptor.setJSFComponent(category |
| .isJSFComponentCategory()); |
| descriptor.setURI(uri); |
| |
| String tagName = item |
| .getAttribute(IPaletteConstants.TAGNAME); |
| descriptor.setTagName(tagName); |
| |
| String label = item.getAttribute(IPaletteConstants.LABEL); |
| descriptor.setLabel(label); |
| |
| StringBuffer id = new StringBuffer(uri); |
| id.append(":").append(tagName).append(":").append(label); |
| descriptor.setId(id.toString()); |
| |
| String shortDesc = item |
| .getAttribute(IPaletteConstants.SHORTDESC); |
| descriptor.setDescription(shortDesc); |
| |
| String smallIcon = item |
| .getAttribute(IPaletteConstants.SMALLICON); |
| descriptor.setSmallIcon(getImageDescriptor(bundle, prefix, |
| smallIcon)); |
| |
| String largeIcon = item |
| .getAttribute(IPaletteConstants.LARGEICON); |
| descriptor.setLargeIcon(getImageDescriptor(bundle, prefix, |
| largeIcon)); |
| |
| String expert = item.getAttribute(IPaletteConstants.EXPERT); |
| boolean isVisible = !Boolean.TRUE.toString() |
| .equalsIgnoreCase(expert); //$NON-NLS-1$ |
| descriptor.setVisible(isVisible); |
| |
| String requireHForm = item |
| .getAttribute(IPaletteConstants.REQUIREHFORM); |
| boolean r = Boolean.TRUE.toString().equalsIgnoreCase( |
| requireHForm); |
| descriptor.setRequireHForm(r); |
| |
| NodeList attributes = item |
| .getElementsByTagName(IPaletteConstants.ATTRIBUTE_TAG); |
| if (attributes.getLength() > 0) { |
| Map attrMap = new HashMap(); |
| for (int k = 0, klength = attributes.getLength(); k < klength; k++) { |
| Element attr = (Element) attributes.item(k); |
| String name = attr |
| .getAttribute(IPaletteConstants.NAME); |
| String value = attr |
| .getAttribute(IPaletteConstants.VALUE); |
| attrMap.put(name, value); |
| } |
| descriptor.setInitialAttributes(attrMap); |
| } |
| |
| descriptor.setTemplateSubNodes(PaletteElementTemplateHelper |
| .readTemplate(item)); |
| category.addPaletteItem(descriptor); |
| } |
| } |
| } catch (Exception ex) { |
| ex.printStackTrace(); |
| } |
| } |
| |
| /** |
| * @param plugin |
| * @param prefix |
| * @param smallIcon2 |
| * @return |
| */ |
| private static ImageDescriptor getImageDescriptor(Bundle bundle, |
| String prefix, String u) { |
| if (u == null || u.length() == 0) { |
| return null; |
| } |
| String path = (prefix == null ? "" : prefix) + u; |
| URL url = bundle.getEntry(path); |
| return ImageDescriptor.createFromURL(url); |
| } |
| } |