/*******************************************************************************
* Copyright (c) 2001, 2009 IBM Corporation 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:
* IBM Corporation - initial API and implementation
* Naoki Akiyama, Fujitsu - Bug 244901 - Cannot set xsd:annotation to
* xsd:redefine by Properties view.
*******************************************************************************/
package org.eclipse.wst.xsd.ui.internal.common.util;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Stack;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.DecorationOverlayIcon;
import org.eclipse.jface.viewers.IDecoration;
import org.eclipse.swt.custom.CCombo;
import org.eclipse.swt.custom.CLabel;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.views.properties.tabbed.TabbedPropertySheetWidgetFactory;
import org.eclipse.wst.sse.core.internal.format.IStructuredFormatProcessor;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
import org.eclipse.wst.xml.core.internal.provisional.format.FormatProcessorXML;
import org.eclipse.wst.xsd.ui.internal.adt.design.ImageOverlayDescriptor;
import org.eclipse.wst.xsd.ui.internal.common.properties.sections.AbstractSection;
import org.eclipse.wst.xsd.ui.internal.editor.XSDEditorPlugin;
import org.eclipse.xsd.XSDAnnotation;
import org.eclipse.xsd.XSDAttributeDeclaration;
import org.eclipse.xsd.XSDAttributeGroupDefinition;
import org.eclipse.xsd.XSDAttributeUse;
import org.eclipse.xsd.XSDComplexTypeContent;
import org.eclipse.xsd.XSDComplexTypeDefinition;
import org.eclipse.xsd.XSDConcreteComponent;
import org.eclipse.xsd.XSDElementDeclaration;
import org.eclipse.xsd.XSDEnumerationFacet;
import org.eclipse.xsd.XSDFacet;
import org.eclipse.xsd.XSDFactory;
import org.eclipse.xsd.XSDFeature;
import org.eclipse.xsd.XSDIdentityConstraintDefinition;
import org.eclipse.xsd.XSDImport;
import org.eclipse.xsd.XSDInclude;
import org.eclipse.xsd.XSDModelGroup;
import org.eclipse.xsd.XSDModelGroupDefinition;
import org.eclipse.xsd.XSDNamedComponent;
import org.eclipse.xsd.XSDNotationDeclaration;
import org.eclipse.xsd.XSDParticle;
import org.eclipse.xsd.XSDRedefine;
import org.eclipse.xsd.XSDSchema;
import org.eclipse.xsd.XSDSimpleTypeDefinition;
import org.eclipse.xsd.XSDTypeDefinition;
import org.eclipse.xsd.XSDWildcard;
import org.eclipse.xsd.XSDXPathDefinition;
import org.eclipse.xsd.util.XSDConstants;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
public class XSDCommonUIUtils
{
public XSDCommonUIUtils()
{
super();
}
public static Image getUpdatedImage(XSDConcreteComponent input, Image baseImage, boolean isReadOnly)
{
XSDAnnotation xsdAnnotation = getInputXSDAnnotation(input, false);
if (xsdAnnotation != null)
{
if (xsdAnnotation.getApplicationInformation().size() > 0)
{
// Will use the class name appended by the read only state as the name of the image.
// There is a disabled and an enabled version of each baseImage, so we can't simply
// use the component name as the name of the image
String imageName = input.getClass().getName() + isReadOnly;
Image newImage = XSDEditorPlugin.getDefault().getImageRegistry().get(imageName);
if (newImage == null)
{
ImageOverlayDescriptor ovr = new ImageOverlayDescriptor(baseImage, isReadOnly);
newImage = ovr.getImage();
XSDEditorPlugin.getDefault().getImageRegistry().put(imageName, newImage);
}
return newImage;
}
}
return baseImage;
}
public static XSDAnnotation getInputXSDAnnotation(XSDConcreteComponent input, boolean createIfNotExist)
{
XSDAnnotation xsdAnnotation = null;
XSDFactory factory = XSDFactory.eINSTANCE;
if (input instanceof XSDAttributeDeclaration)
{
XSDAttributeDeclaration xsdComp = (XSDAttributeDeclaration) input;
xsdAnnotation = xsdComp.getAnnotation();
if (createIfNotExist && xsdAnnotation == null)
{
xsdAnnotation = factory.createXSDAnnotation();
xsdComp.setAnnotation(xsdAnnotation);
}
}
else if (input instanceof XSDAttributeGroupDefinition)
{
XSDAttributeGroupDefinition xsdComp = (XSDAttributeGroupDefinition) input;
xsdAnnotation = xsdComp.getAnnotation();
if (createIfNotExist && xsdAnnotation == null)
{
xsdAnnotation = factory.createXSDAnnotation();
xsdComp.setAnnotation(xsdAnnotation);
}
}
else if (input instanceof XSDElementDeclaration)
{
XSDElementDeclaration xsdComp = (XSDElementDeclaration) input;
xsdAnnotation = xsdComp.getAnnotation();
if (createIfNotExist && xsdAnnotation == null)
{
xsdAnnotation = factory.createXSDAnnotation();
xsdComp.setAnnotation(xsdAnnotation);
}
}
else if (input instanceof XSDNotationDeclaration)
{
XSDNotationDeclaration xsdComp = (XSDNotationDeclaration) input;
xsdAnnotation = xsdComp.getAnnotation();
if (createIfNotExist && xsdAnnotation == null)
{
xsdAnnotation = factory.createXSDAnnotation();
xsdComp.setAnnotation(xsdAnnotation);
}
}
else if (input instanceof XSDXPathDefinition)
{
XSDXPathDefinition xsdComp = (XSDXPathDefinition) input;
xsdAnnotation = xsdComp.getAnnotation();
if (createIfNotExist && xsdAnnotation == null)
{
xsdAnnotation = factory.createXSDAnnotation();
xsdComp.setAnnotation(xsdAnnotation);
}
}
else if (input instanceof XSDModelGroup)
{
XSDModelGroup xsdComp = (XSDModelGroup) input;
xsdAnnotation = xsdComp.getAnnotation();
if (createIfNotExist && xsdAnnotation == null)
{
xsdAnnotation = factory.createXSDAnnotation();
xsdComp.setAnnotation(xsdAnnotation);
}
}
else if (input instanceof XSDModelGroupDefinition)
{
XSDModelGroupDefinition xsdComp = (XSDModelGroupDefinition) input;
xsdAnnotation = xsdComp.getAnnotation();
if (createIfNotExist && xsdAnnotation == null)
{
xsdAnnotation = factory.createXSDAnnotation();
xsdComp.setAnnotation(xsdAnnotation);
}
}
else if (input instanceof XSDIdentityConstraintDefinition)
{
XSDIdentityConstraintDefinition xsdComp = (XSDIdentityConstraintDefinition) input;
xsdAnnotation = xsdComp.getAnnotation();
if (createIfNotExist && xsdAnnotation == null)
{
xsdAnnotation = factory.createXSDAnnotation();
xsdComp.setAnnotation(xsdAnnotation);
}
}
else if (input instanceof XSDWildcard)
{
XSDWildcard xsdComp = (XSDWildcard) input;
xsdAnnotation = xsdComp.getAnnotation();
if (createIfNotExist && xsdAnnotation == null)
{
xsdAnnotation = factory.createXSDAnnotation();
xsdComp.setAnnotation(xsdAnnotation);
}
}
else if (input instanceof XSDSchema)
{
XSDSchema xsdComp = (XSDSchema) input;
List list = xsdComp.getAnnotations();
if (list.size() > 0)
{
xsdAnnotation = (XSDAnnotation) list.get(0);
}
else
{
if (createIfNotExist && xsdAnnotation == null)
{
xsdAnnotation = factory.createXSDAnnotation();
if (xsdComp.getContents() != null)
{
xsdComp.getContents().add(0, xsdAnnotation);
}
}
}
return xsdAnnotation;
}
else if (input instanceof XSDFacet)
{
XSDFacet xsdComp = (XSDFacet) input;
xsdAnnotation = xsdComp.getAnnotation();
if (createIfNotExist && xsdAnnotation == null)
{
xsdAnnotation = factory.createXSDAnnotation();
xsdComp.setAnnotation(xsdAnnotation);
}
}
else if (input instanceof XSDTypeDefinition)
{
XSDTypeDefinition xsdComp = (XSDTypeDefinition) input;
xsdAnnotation = xsdComp.getAnnotation();
if (createIfNotExist && xsdAnnotation == null)
{
xsdAnnotation = factory.createXSDAnnotation();
xsdComp.setAnnotation(xsdAnnotation);
}
}
else if (input instanceof XSDInclude)
{
XSDInclude xsdComp = (XSDInclude) input;
xsdAnnotation = xsdComp.getAnnotation();
if (createIfNotExist && xsdAnnotation == null)
{
xsdAnnotation = factory.createXSDAnnotation();
xsdComp.setAnnotation(xsdAnnotation);
}
}
else if (input instanceof XSDImport)
{
XSDImport xsdComp = (XSDImport) input;
xsdAnnotation = xsdComp.getAnnotation();
if (createIfNotExist && xsdAnnotation == null)
{
xsdAnnotation = factory.createXSDAnnotation();
xsdComp.setAnnotation(xsdAnnotation);
}
}
else if (input instanceof XSDRedefine)
{
XSDRedefine xsdComp = (XSDRedefine) input;
List contents = xsdComp.getContents();
for (int i = 0; i < contents.size(); i++)
{
Object content = contents.get(i);
if (content instanceof XSDAnnotation)
{
xsdAnnotation = (XSDAnnotation) content;
break;
}
}
if (createIfNotExist && xsdAnnotation == null)
{
xsdAnnotation = factory.createXSDAnnotation();
contents.add(0, xsdAnnotation);
}
return xsdAnnotation;
}
else if (input instanceof XSDAnnotation)
{
xsdAnnotation = (XSDAnnotation) input;
}
if (createIfNotExist)
{
formatAnnotation(xsdAnnotation);
}
return xsdAnnotation;
}
private static void formatAnnotation(XSDAnnotation annotation)
{
Element element = annotation.getElement();
formatChild(element);
}
public static void formatChild(Node child)
{
if (child instanceof IDOMNode)
{
IDOMModel model = ((IDOMNode) child).getModel();
try
{
// tell the model that we are about to make a big model change
model.aboutToChangeModel();
IStructuredFormatProcessor formatProcessor = new FormatProcessorXML();
formatProcessor.formatNode(child);
}
finally
{
// tell the model that we are done with the big model change
model.changedModel();
}
}
}
public static String createUniqueElementName(String prefix, List elements)
{
ArrayList usedNames = new ArrayList();
for (Iterator i = elements.iterator(); i.hasNext();)
{
usedNames.add(getDisplayName((XSDNamedComponent) i.next()));
}
int i = 1;
String testName = prefix;
while (usedNames.contains(testName))
{
testName = prefix + i++;
}
return testName;
}
public static String createUniqueEnumerationValue(String prefix, List elements)
{
ArrayList usedNames = new ArrayList();
for (Iterator i = elements.iterator(); i.hasNext();)
{
usedNames.add(((XSDEnumerationFacet) i.next()).getLexicalValue());
}
int i = 1;
String testName = prefix;
while (usedNames.contains(testName))
{
testName = prefix + i++;
}
return testName;
}
public static String getDisplayName(XSDNamedComponent component)
{
if (component instanceof XSDTypeDefinition)
return getDisplayNameFromXSDType((XSDTypeDefinition) component);
if (component instanceof XSDFeature)
{
XSDFeature feature = (XSDFeature) component;
if (feature.getName() != null)
return feature.getName();
else if (feature.getResolvedFeature() != null && feature.getResolvedFeature().getName() != null)
return feature.getResolvedFeature().getName();
}
return component.getName();
}
public static String getDisplayNameFromXSDType(XSDTypeDefinition type)
{
return getDisplayNameFromXSDType(type, true);
}
public static String getDisplayNameFromXSDType(XSDTypeDefinition type, boolean returnPrimitiveParents)
{
if (type == null)
return null;
if (type.getName() == null || type.getName().length() == 0)
{
if (returnPrimitiveParents && isPrimitiveType(type))
{
return getDisplayNameFromXSDType(type.getBaseType());
}
EObject container = type.eContainer();
while (container != null)
{
if (container instanceof XSDNamedComponent && ((XSDNamedComponent) container).getName() != null)
{
return ((XSDNamedComponent) container).getName();
}
container = container.eContainer();
}
return null;
}
else
return type.getName();
}
public static boolean isPrimitiveType(XSDTypeDefinition type)
{
if (type instanceof XSDComplexTypeDefinition)
return false;
XSDTypeDefinition baseType = null;
if (type != null)
{
baseType = type.getBaseType();
XSDTypeDefinition origType = baseType; // KC: although invalid, we need to
// prevent cycles and to avoid an
// infinite loop
while (baseType != null && !XSDConstants.isAnySimpleType(baseType) && !XSDConstants.isAnyType(baseType) && origType != baseType)
{
type = baseType;
baseType = type.getBaseType();
}
baseType = type;
}
else
{
return false;
}
return (XSDConstants.SCHEMA_FOR_SCHEMA_URI_2001.equals(baseType.getTargetNamespace()));
}
public static XSDSimpleTypeDefinition getAnonymousSimpleType(XSDFeature input, XSDSimpleTypeDefinition xsdSimpleTypeDefinition)
{
XSDSimpleTypeDefinition anonymousSimpleType = null;
XSDTypeDefinition localType = null;
if (input instanceof XSDElementDeclaration)
{
localType = ((XSDElementDeclaration) input).getAnonymousTypeDefinition();
}
else if (input instanceof XSDAttributeDeclaration)
{
localType = ((XSDAttributeDeclaration) input).getAnonymousTypeDefinition();
}
if (localType instanceof XSDSimpleTypeDefinition)
{
anonymousSimpleType = (XSDSimpleTypeDefinition) localType;
}
return anonymousSimpleType;
}
// bug246036 - check for cyclic groups. We should refactor out this static class.
private static Stack visitedGroups = new Stack();
public static void resetVisitedGroupsStack()
{
visitedGroups.clear();
}
public static List getChildElements(XSDModelGroup group)
{
List children = new ArrayList();
visitedGroups.push(group);
if (group == null) return children;
for (Iterator i = group.getContents().iterator(); i.hasNext();)
{
XSDParticle next = (XSDParticle) i.next();
if (next.getContent() instanceof XSDFeature)
{
if (children.contains(next.getContent())) break;
children.add(next.getContent());
}
else if (next.getTerm() instanceof XSDModelGroup)
{
if (!visitedGroups.contains(group))
children.addAll(getChildElements((XSDModelGroup) next.getTerm()));
}
}
visitedGroups.pop();
return children;
}
public static List getAllAttributes(XSDComplexTypeDefinition xsdComplexType)
{
List attributes = getChildElements(xsdComplexType);
attributes.addAll(getChildAttributes(xsdComplexType));
return attributes;
}
public static List getAllAttributes(XSDModelGroupDefinition xsdModelGroupDefinition)
{
List attributes = getChildElements(xsdModelGroupDefinition);
return attributes;
}
public static List getInheritedAttributes(XSDComplexTypeDefinition ct)
{
List attrs = new ArrayList();
XSDTypeDefinition parent = ct.getBaseTypeDefinition();
if (parent != null && parent instanceof XSDComplexTypeDefinition && ct.isSetDerivationMethod())
{
attrs.addAll(getAllAttributes((XSDComplexTypeDefinition) parent));
if (! ct.isCircular()) attrs.addAll(getInheritedAttributes((XSDComplexTypeDefinition) parent));
}
return attrs;
}
public static List getChildElements(XSDComplexTypeDefinition ct)
{
return getChildElements(getModelGroup(ct));
}
public static List getChildElements(XSDModelGroupDefinition xsdModelGroupDefinition)
{
return getChildElements(xsdModelGroupDefinition.getModelGroup());
}
public static XSDModelGroup getModelGroup(XSDComplexTypeDefinition cType)
{
XSDParticle particle = cType.getComplexType();
if (particle == null || particle.eContainer() != cType)
return null;
Object particleContent = particle.getContent();
XSDModelGroup group = null;
if (particleContent instanceof XSDModelGroupDefinition)
group = ((XSDModelGroupDefinition) particleContent).getResolvedModelGroupDefinition().getModelGroup();
else if (particleContent instanceof XSDModelGroup)
group = (XSDModelGroup) particleContent;
if (group == null)
return null;
if (group.getContents().isEmpty() || group.eResource() != cType.eResource())
{
XSDComplexTypeContent content = cType.getContent();
if (content instanceof XSDParticle)
group = (XSDModelGroup) ((XSDParticle) content).getContent();
}
return group;
}
public static List getChildAttributes(XSDComplexTypeDefinition ct)
{
EList attrContents = ct.getAttributeContents();
List attrs = new ArrayList();
for (int i = 0; i < attrContents.size(); i++)
{
Object next = attrContents.get(i);
if (next instanceof XSDAttributeUse)
{
attrs.add(((XSDAttributeUse) next).getContent().getResolvedAttributeDeclaration());
}
else if (next instanceof XSDAttributeGroupDefinition)
{
//XSDAttributeGroupDefinition attrGroup = (XSDAttributeGroupDefinition) next;
}
}
return attrs;
}
public static Image getImageWithErrorOverlay(XSDConcreteComponent input, Image baseImage, boolean isReadOnly)
{
Image extensionImage = getUpdatedImage(input, baseImage, isReadOnly);
ImageDescriptor errorOverlay = XSDEditorPlugin.getImageDescriptor("icons/ovr16/error_ovr.gif"); //$NON-NLS-1$
if (baseImage == extensionImage)
{
String imageName = input.getClass().getName() + "_error_" + isReadOnly;
Image newImage = XSDEditorPlugin.getDefault().getImageRegistry().get(imageName);
if (newImage == null)
{
DecorationOverlayIcon ovr = new DecorationOverlayIcon(baseImage, errorOverlay, IDecoration.TOP_LEFT);
newImage = ovr.createImage();
XSDEditorPlugin.getDefault().getImageRegistry().put(imageName, newImage);
}
return newImage;
}
else
{
String imageName = input.getClass().getName() + "_extension_error_" + isReadOnly;
Image newImage = XSDEditorPlugin.getDefault().getImageRegistry().get(imageName);
if (newImage == null)
{
DecorationOverlayIcon ovr = new DecorationOverlayIcon(extensionImage, errorOverlay, IDecoration.TOP_LEFT);
newImage = ovr.createImage();
XSDEditorPlugin.getDefault().getImageRegistry().put(imageName, newImage);
}
return newImage;
}
}
public static CCombo getNewPropertiesCombo(Composite composite, TabbedPropertySheetWidgetFactory widgetFactory,
AbstractSection listener, String[] items, String helpID)
{
CCombo combo = widgetFactory.createCCombo(composite);
combo.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
combo.setEditable(false);
combo.setItems(items);
combo.addSelectionListener(listener);
PlatformUI.getWorkbench().getHelpSystem().setHelp(combo, helpID);
return combo;
}
public static CLabel getNewPropertiesLabel(Composite composite, TabbedPropertySheetWidgetFactory widgetFactory,
String labelText)
{
// Create label
CLabel label;
label = widgetFactory.createCLabel(composite, labelText);
GridData data = new GridData();
data.horizontalAlignment = GridData.HORIZONTAL_ALIGN_BEGINNING;
data.grabExcessHorizontalSpace = false;
label.setLayoutData(data);
return label;
}
}