| /******************************************************************************* |
| * Copyright (c) 2001, 2006 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 |
| *******************************************************************************/ |
| package org.eclipse.wst.xsd.ui.internal.adapters; |
| |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.emf.common.notify.Adapter; |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.gef.commands.Command; |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IWorkbench; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.wst.xsd.ui.internal.adt.actions.BaseSelectionAction; |
| import org.eclipse.wst.xsd.ui.internal.adt.actions.DeleteAction; |
| import org.eclipse.wst.xsd.ui.internal.adt.actions.SetInputToGraphView; |
| import org.eclipse.wst.xsd.ui.internal.adt.actions.ShowPropertiesViewAction; |
| import org.eclipse.wst.xsd.ui.internal.adt.facade.IADTObject; |
| import org.eclipse.wst.xsd.ui.internal.adt.facade.IADTObjectListener; |
| import org.eclipse.wst.xsd.ui.internal.adt.facade.IComplexType; |
| import org.eclipse.wst.xsd.ui.internal.adt.facade.IModel; |
| import org.eclipse.wst.xsd.ui.internal.adt.facade.IType; |
| import org.eclipse.wst.xsd.ui.internal.adt.outline.ITreeElement; |
| import org.eclipse.wst.xsd.ui.internal.common.actions.AddXSDAnyAttributeAction; |
| import org.eclipse.wst.xsd.ui.internal.common.actions.AddXSDAttributeDeclarationAction; |
| import org.eclipse.wst.xsd.ui.internal.common.actions.AddXSDAttributeGroupDefinitionAction; |
| import org.eclipse.wst.xsd.ui.internal.common.actions.AddXSDElementAction; |
| import org.eclipse.wst.xsd.ui.internal.common.actions.AddXSDModelGroupAction; |
| import org.eclipse.wst.xsd.ui.internal.common.actions.OpenInNewEditor; |
| import org.eclipse.wst.xsd.ui.internal.common.commands.AddXSDElementCommand; |
| import org.eclipse.wst.xsd.ui.internal.common.commands.DeleteCommand; |
| import org.eclipse.wst.xsd.ui.internal.common.commands.UpdateNameCommand; |
| import org.eclipse.wst.xsd.ui.internal.design.editparts.model.SpaceFiller; |
| import org.eclipse.wst.xsd.ui.internal.design.editparts.model.TargetConnectionSpaceFiller; |
| import org.eclipse.wst.xsd.ui.internal.editor.Messages; |
| import org.eclipse.wst.xsd.ui.internal.editor.XSDEditorPlugin; |
| import org.eclipse.xsd.XSDAttributeGroupContent; |
| import org.eclipse.xsd.XSDAttributeGroupDefinition; |
| import org.eclipse.xsd.XSDAttributeUse; |
| import org.eclipse.xsd.XSDComplexTypeContent; |
| import org.eclipse.xsd.XSDComplexTypeDefinition; |
| import org.eclipse.xsd.XSDModelGroup; |
| import org.eclipse.xsd.XSDParticle; |
| import org.eclipse.xsd.XSDParticleContent; |
| import org.eclipse.xsd.XSDSchema; |
| import org.eclipse.xsd.XSDTypeDefinition; |
| import org.eclipse.xsd.util.XSDConstants; |
| |
| public class XSDComplexTypeDefinitionAdapter extends XSDTypeDefinitionAdapter implements IComplexType, IADTObjectListener |
| { |
| protected List fields = null; |
| protected List otherThingsToListenTo = null; |
| |
| public XSDComplexTypeDefinition getXSDComplexTypeDefinition() |
| { |
| return (XSDComplexTypeDefinition) target; |
| } |
| |
| public IType getSuperType() |
| { |
| XSDTypeDefinition td = getXSDTypeDefinition().getBaseType(); |
| |
| // test to filter out the 'anyType' type ... don't want to see that |
| // |
| if (td != null && !td.getName().equals("anyType")) //$NON-NLS-1$ |
| { |
| return (IType) XSDAdapterFactory.getInstance().adapt(td); |
| } |
| return null; |
| } |
| |
| protected void clearFields() |
| { |
| if (otherThingsToListenTo != null) |
| { |
| for (Iterator i = otherThingsToListenTo.iterator(); i.hasNext();) |
| { |
| Adapter adapter = (Adapter) i.next(); |
| if (adapter instanceof IADTObject) |
| { |
| IADTObject adtObject = (IADTObject) adapter; |
| adtObject.unregisterListener(this); |
| } |
| } |
| } |
| fields = null; |
| otherThingsToListenTo = null; |
| } |
| |
| public List getFields() |
| { |
| if (fields == null) |
| { |
| fields = new ArrayList(); |
| otherThingsToListenTo = new ArrayList(); |
| |
| XSDVisitorForFields visitor = new XSDVisitorForFieldsWithSpaceFillers(); |
| visitor.visitComplexTypeDefinition(getXSDComplexTypeDefinition()); |
| populateAdapterList(visitor.concreteComponentList, fields); |
| populateAdapterList(visitor.thingsWeNeedToListenTo, otherThingsToListenTo); |
| for (Iterator i = otherThingsToListenTo.iterator(); i.hasNext();) |
| { |
| Adapter adapter = (Adapter) i.next(); |
| if (adapter instanceof IADTObject) |
| { |
| IADTObject adtObject = (IADTObject) adapter; |
| adtObject.registerListener(this); |
| } |
| } |
| } |
| return fields; |
| } |
| |
| class XSDVisitorForFieldsWithSpaceFillers extends XSDVisitorForFields |
| { |
| public XSDVisitorForFieldsWithSpaceFillers() |
| { |
| super(); |
| } |
| |
| public void visitAttributeGroupDefinition(XSDAttributeGroupDefinition attributeGroup) |
| { |
| for (Iterator it = attributeGroup.getContents().iterator(); it.hasNext();) |
| { |
| Object o = it.next(); |
| if (o instanceof XSDAttributeUse) |
| { |
| XSDAttributeUse attributeUse = (XSDAttributeUse) o; |
| concreteComponentList.add(attributeUse.getAttributeDeclaration()); |
| thingsWeNeedToListenTo.add(attributeUse.getAttributeDeclaration()); |
| } |
| else if (o instanceof XSDAttributeGroupDefinition) |
| { |
| XSDAttributeGroupDefinition attrGroup = (XSDAttributeGroupDefinition) o; |
| thingsWeNeedToListenTo.add(attrGroup); |
| if (attrGroup.isAttributeGroupDefinitionReference()) |
| { |
| attrGroup = attrGroup.getResolvedAttributeGroupDefinition(); |
| if (attrGroup.getContents().size() == 0) |
| { |
| concreteComponentList.add(new SpaceFiller("attribute")); //$NON-NLS-1$ |
| } |
| visitAttributeGroupDefinition(attrGroup); |
| } |
| } |
| } |
| } |
| |
| public void visitModelGroup(XSDModelGroup modelGroup) |
| { |
| int numOfChildren = modelGroup.getContents().size(); |
| if (numOfChildren == 0) |
| { |
| concreteComponentList.add(new SpaceFiller("element")); //$NON-NLS-1$ |
| } |
| super.visitModelGroup(modelGroup); |
| } |
| } |
| |
| public List getModelGroups() |
| { |
| List groups = new ArrayList(); |
| groups.addAll(XSDChildUtility.getModelChildren(getXSDComplexTypeDefinition())); |
| return groups; |
| } |
| |
| public List getAttributeGroupContent() |
| { |
| EList attrContent = getXSDComplexTypeDefinition().getAttributeContents(); |
| List attrUses = new ArrayList(); |
| List list = new ArrayList(); |
| |
| for (Iterator it = attrContent.iterator(); it.hasNext();) |
| { |
| XSDAttributeGroupContent attrGroupContent = (XSDAttributeGroupContent) it.next(); |
| |
| if (attrGroupContent instanceof XSDAttributeGroupDefinition) |
| { |
| XSDAttributeGroupDefinition attributeGroupDefinition = (XSDAttributeGroupDefinition) attrGroupContent; |
| list.add(XSDAdapterFactory.getInstance().adapt(attributeGroupDefinition)); |
| getAttributeUses(attributeGroupDefinition, attrUses); |
| } |
| else |
| { |
| attrUses.add(attrGroupContent); |
| list.add(new TargetConnectionSpaceFiller(this)); |
| } |
| } |
| return list; |
| } |
| |
| public boolean isComplexType() |
| { |
| return true; |
| } |
| |
| public void notifyChanged(Notification msg) |
| { |
| clearFields(); |
| super.notifyChanged(msg); |
| } |
| |
| public Command getUpdateNameCommand(String newName) |
| { |
| return new UpdateNameCommand(Messages._UI_ACTION_UPDATE_NAME, getXSDComplexTypeDefinition(), newName); |
| } |
| |
| public Command getAddNewFieldCommand(String fieldKind) |
| { |
| return new AddXSDElementCommand(Messages._UI_ACTION_ADD_FIELD, getXSDComplexTypeDefinition()); |
| } |
| |
| public Command getDeleteCommand() |
| { |
| return new DeleteCommand("", getXSDComplexTypeDefinition()); //$NON-NLS-1$ |
| } |
| |
| protected class AddNewFieldCommand extends Command |
| { |
| protected String defaultName; |
| protected String fieldKind; |
| |
| AddNewFieldCommand(String defaultName, String fieldKind) |
| { |
| this.defaultName = defaultName; |
| this.fieldKind = fieldKind; |
| } |
| } |
| |
| public String[] getActions(Object object) |
| { |
| List list = new ArrayList(); |
| IWorkbench workbench = PlatformUI.getWorkbench(); |
| IWorkbenchWindow workbenchWindow = workbench.getActiveWorkbenchWindow(); |
| IEditorPart editorPart = workbenchWindow.getActivePage().getActiveEditor(); |
| Object schema = editorPart.getAdapter(XSDSchema.class); |
| |
| list.add(AddXSDElementAction.ID); |
| list.add(AddXSDElementAction.REF_ID); |
| list.add(AddXSDAttributeDeclarationAction.ID); |
| list.add(AddXSDAttributeDeclarationAction.REF_ID); |
| list.add(AddXSDAttributeGroupDefinitionAction.REF_ID); |
| list.add(AddXSDAnyAttributeAction.ID); |
| list.add(BaseSelectionAction.SEPARATOR_ID); |
| list.add(AddXSDModelGroupAction.SEQUENCE_ID); |
| list.add(AddXSDModelGroupAction.CHOICE_ID); |
| |
| list.add(BaseSelectionAction.SEPARATOR_ID); |
| list.add(DeleteAction.ID); |
| list.add(BaseSelectionAction.SEPARATOR_ID); |
| if (getXSDComplexTypeDefinition().getSchema() == schema) |
| { |
| if (getXSDComplexTypeDefinition().getContainer() == schema) |
| { |
| list.add(SetInputToGraphView.ID); |
| } |
| } |
| else |
| { |
| list.add(OpenInNewEditor.ID); |
| } |
| list.add(BaseSelectionAction.SEPARATOR_ID); |
| list.add(ShowPropertiesViewAction.ID); |
| String[] result = new String[list.size()]; |
| list.toArray(result); |
| return result; |
| } |
| |
| public void propertyChanged(Object object, String property) |
| { |
| clearFields(); |
| notifyListeners(this, null); |
| } |
| |
| class BogusAction extends Action |
| { |
| BogusAction(String name) |
| { |
| super(name); |
| } |
| |
| public void run() |
| { |
| // TODO Auto-generated method stub |
| super.run(); |
| } |
| } |
| |
| public ITreeElement[] getChildren() |
| { |
| XSDComplexTypeDefinition xsdComplexTypeDefinition = getXSDComplexTypeDefinition(); |
| List list = new ArrayList(); |
| // Add attributes |
| for (Iterator i = xsdComplexTypeDefinition.getAttributeContents().iterator(); i.hasNext();) |
| { |
| Object obj = i.next(); |
| if (obj instanceof XSDAttributeUse) |
| { |
| list.add(obj); |
| } |
| else if (obj instanceof XSDAttributeGroupDefinition) |
| { |
| getAttributeUses((XSDAttributeGroupDefinition) obj, list); |
| } |
| } |
| // get immediate XSD Model Group of this complex type |
| if (xsdComplexTypeDefinition.getContent() != null) |
| { |
| XSDComplexTypeContent xsdComplexTypeContent = xsdComplexTypeDefinition.getContent(); |
| if (xsdComplexTypeContent instanceof XSDParticle) |
| { |
| XSDParticleContent particleContent = ((XSDParticle) xsdComplexTypeContent).getContent(); |
| if (particleContent instanceof XSDModelGroup) |
| { |
| list.add(particleContent); |
| } |
| } |
| } |
| // get inherited XSD Model Group of this complex type |
| boolean showInheritedContent = XSDEditorPlugin.getPlugin().getShowInheritedContent(); |
| if (showInheritedContent) |
| { |
| XSDTypeDefinition typeDef = xsdComplexTypeDefinition.getBaseTypeDefinition(); |
| if (typeDef instanceof XSDComplexTypeDefinition) |
| { |
| XSDComplexTypeDefinition baseCT = (XSDComplexTypeDefinition) typeDef; |
| if (baseCT.getTargetNamespace() != null && !baseCT.getTargetNamespace().equals(XSDConstants.SCHEMA_FOR_SCHEMA_URI_2001)) |
| { |
| if (baseCT.getContent() != null) |
| { |
| XSDComplexTypeContent xsdComplexTypeContent = baseCT.getContent(); |
| if (xsdComplexTypeContent instanceof XSDParticle) |
| { |
| XSDParticleContent particleContent = ((XSDParticle) xsdComplexTypeContent).getContent(); |
| if (particleContent instanceof XSDModelGroup) |
| { |
| list.add(particleContent); |
| } |
| } |
| } |
| } |
| } |
| } |
| List adapterList = new ArrayList(); |
| populateAdapterList(list, adapterList); |
| return (ITreeElement[]) adapterList.toArray(new ITreeElement[0]); |
| } |
| |
| public Image getImage() |
| { |
| if (isReadOnly()) |
| { |
| return XSDEditorPlugin.getPlugin().getIcon("obj16/XSDComplexTypedis.gif"); //$NON-NLS-1$ |
| } |
| return XSDEditorPlugin.getPlugin().getIcon("obj16/XSDComplexType.gif"); //$NON-NLS-1$ |
| } |
| |
| public String getText() |
| { |
| XSDComplexTypeDefinition xsdComplexTypeDefinition = (XSDComplexTypeDefinition) target; |
| |
| StringBuffer result = new StringBuffer(); |
| |
| result.append(xsdComplexTypeDefinition.getName() == null ? "local type" : xsdComplexTypeDefinition.getName()); //$NON-NLS-1$ |
| |
| XSDTypeDefinition baseTypeDefinition = xsdComplexTypeDefinition.getBaseTypeDefinition(); |
| if (baseTypeDefinition != null && baseTypeDefinition != xsdComplexTypeDefinition.getContent() && baseTypeDefinition.getName() != null && !XSDConstants.isURType(baseTypeDefinition)) |
| { |
| result.append(" : "); //$NON-NLS-1$ |
| result.append(baseTypeDefinition.getQName(xsdComplexTypeDefinition)); |
| } |
| |
| return result.toString(); |
| } |
| |
| public void getAttributeUses(XSDAttributeGroupDefinition attributeGroupDefinition, List list) |
| { |
| Iterator i = attributeGroupDefinition.getResolvedAttributeGroupDefinition().getContents().iterator(); |
| |
| while (i.hasNext()) |
| { |
| XSDAttributeGroupContent attrGroupContent = (XSDAttributeGroupContent) i.next(); |
| |
| if (attrGroupContent instanceof XSDAttributeGroupDefinition) |
| { |
| getAttributeUses((XSDAttributeGroupDefinition) attrGroupContent, list); |
| } |
| else |
| { |
| list.add(XSDAdapterFactory.getInstance().adapt(attrGroupContent)); |
| } |
| } |
| } |
| |
| public IModel getModel() |
| { |
| Adapter adapter = XSDAdapterFactory.getInstance().adapt(getXSDComplexTypeDefinition().getSchema()); |
| return (IModel)adapter; |
| } |
| |
| public boolean isFocusAllowed() |
| { |
| return true; |
| } |
| } |