| /******************************************************************************* |
| * 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 |
| *******************************************************************************/ |
| package org.eclipse.wst.xsd.ui.internal.navigation; |
| |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| import org.eclipse.emf.common.notify.Adapter; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.gef.GraphicalViewer; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IMemento; |
| import org.eclipse.ui.INavigationLocation; |
| import org.eclipse.ui.NavigationLocation; |
| import org.eclipse.wst.xsd.ui.internal.adapters.XSDAdapterFactory; |
| import org.eclipse.wst.xsd.ui.internal.adapters.XSDVisitor; |
| import org.eclipse.wst.xsd.ui.internal.adt.design.DesignViewGraphicalViewer; |
| import org.eclipse.wst.xsd.ui.internal.adt.facade.IADTObject; |
| import org.eclipse.xsd.XSDAttributeGroupDefinition; |
| import org.eclipse.xsd.XSDConcreteComponent; |
| import org.eclipse.xsd.XSDElementDeclaration; |
| import org.eclipse.xsd.XSDModelGroupDefinition; |
| import org.eclipse.xsd.XSDRedefine; |
| import org.eclipse.xsd.XSDSchema; |
| import org.eclipse.xsd.XSDTypeDefinition; |
| import com.ibm.icu.util.StringTokenizer; |
| |
| /** |
| * This class exists to support navigation in a context where there is no text |
| * editor page. In these cases we can't rely on the TextSelectionNavigationLocations |
| * so we this class which is designed to work with just the design view. |
| */ |
| public class DesignViewNavigationLocation extends NavigationLocation |
| { |
| protected Path path; |
| |
| private static final String PATH_TAG = "path"; //$NON-NLS-1$ |
| |
| public DesignViewNavigationLocation(IEditorPart part) |
| { |
| super(part); |
| this.path = new Path(); |
| } |
| |
| public DesignViewNavigationLocation(IEditorPart part, XSDConcreteComponent component) |
| { |
| super(part); |
| this.path = Path.computePath(component); |
| } |
| |
| public boolean mergeInto(INavigationLocation currentLocation) |
| { |
| boolean result = false; |
| if (currentLocation instanceof DesignViewNavigationLocation) |
| { |
| DesignViewNavigationLocation loc = (DesignViewNavigationLocation) currentLocation; |
| result = loc.path.toString().equals(path.toString()); |
| } |
| else |
| { |
| } |
| return result; |
| } |
| |
| public void restoreLocation() |
| { |
| XSDSchema schema = (XSDSchema) getEditorPart().getAdapter(XSDSchema.class); |
| Object viewer = getEditorPart().getAdapter(GraphicalViewer.class); |
| if (viewer instanceof DesignViewGraphicalViewer) |
| { |
| DesignViewGraphicalViewer graphicalViewer = (DesignViewGraphicalViewer) viewer; |
| XSDConcreteComponent component = Path.computeComponent(schema, path); |
| if (component != null) |
| { |
| Adapter adapter = XSDAdapterFactory.getInstance().adapt(component); |
| if (adapter instanceof IADTObject) |
| { |
| graphicalViewer.setInput((IADTObject)adapter); |
| } |
| } |
| else if (path.segments.isEmpty()) |
| { |
| Adapter adapter = XSDAdapterFactory.getInstance().adapt(schema); |
| if (adapter instanceof IADTObject) |
| { |
| graphicalViewer.setInput((IADTObject)adapter); |
| } |
| } |
| } |
| } |
| |
| public void restoreState(IMemento memento) |
| { |
| String string = memento.getString(PATH_TAG); |
| path = Path.createPath(string); |
| } |
| |
| public void saveState(IMemento memento) |
| { |
| memento.putString(PATH_TAG, path.toString()); |
| } |
| |
| public void update() |
| { |
| // TODO (cs) not sure what needs to be done here |
| } |
| static class PathSegment |
| { |
| final static int ELEMENT = 1; |
| final static int TYPE = 2; |
| final static int MODEL_GROUP = 3; |
| final static int ATTRIBUTE_GROUP = 4; |
| final static int REDEFINE = 5; |
| int kind; |
| String name; |
| |
| PathSegment() |
| { |
| } |
| |
| PathSegment(int kind, String name) |
| { |
| this.kind = kind; |
| this.name = name; |
| } |
| } |
| protected static class Path |
| { |
| private static final String REDEFINE_TOKEN = "redefine"; //$NON-NLS-1$ |
| private static final String MODEL_GROUP_TOKEN = "modelGroup"; //$NON-NLS-1$ |
| private static final String ATTRIBUTE_GROUP_TOKEN = "attributeGroup"; //$NON-NLS-1$ |
| private static final String TYPE_TOKEN = "type"; //$NON-NLS-1$ |
| private static final String ELEMENT_TOKEN = "element"; //$NON-NLS-1$ |
| |
| List segments = new ArrayList(); |
| |
| public static XSDConcreteComponent computeComponent(XSDSchema schema, Path path) |
| { |
| PathResolvingXSDVisitor visitor = new PathResolvingXSDVisitor(path); |
| visitor.visitSchema(schema); |
| if (visitor.isDone()) |
| { |
| return visitor.result; |
| } |
| return null; |
| } |
| |
| static Path createPath(String pathString) |
| { |
| Path path = new Path(); |
| PathSegment segment = null; |
| for (StringTokenizer st = new StringTokenizer(pathString, "/"); st.hasMoreTokens();) |
| { |
| String token = st.nextToken(); |
| int kind = -1; |
| if (token.startsWith(ELEMENT_TOKEN)) |
| { |
| kind = PathSegment.ELEMENT; |
| } |
| else if (token.startsWith(TYPE_TOKEN)) |
| { |
| kind = PathSegment.TYPE; |
| } |
| else if (token.startsWith(ATTRIBUTE_GROUP_TOKEN)) |
| { |
| kind = PathSegment.ATTRIBUTE_GROUP; |
| } |
| else if (token.startsWith(MODEL_GROUP_TOKEN)) |
| { |
| kind = PathSegment.MODEL_GROUP; |
| } |
| else if (token.startsWith(REDEFINE_TOKEN)) |
| { |
| kind = PathSegment.REDEFINE; |
| } |
| if (kind != -1) |
| { |
| segment = new PathSegment(); |
| segment.kind = kind; |
| path.segments.add(segment); |
| String namePattern = "[@name='"; |
| int startIndex = token.indexOf(namePattern); |
| if (startIndex != -1) |
| { |
| startIndex += namePattern.length(); |
| int endIndex = token.indexOf("']"); |
| if (endIndex != -1) |
| { |
| segment.name = token.substring(startIndex, endIndex); |
| } |
| } |
| } |
| } |
| return path; |
| } |
| |
| public static Path computePath(XSDConcreteComponent component) |
| { |
| Path path = new Path(); |
| for (EObject c = component; c != null; c = c.eContainer()) |
| { |
| if (c instanceof XSDConcreteComponent) |
| { |
| PathSegment segment = computePathSegment((XSDConcreteComponent) c); |
| if (segment != null) |
| { |
| path.segments.add(0, segment); |
| } |
| } |
| } |
| return path; |
| } |
| |
| static PathSegment computePathSegment(XSDConcreteComponent component) |
| { |
| PathSegment pathSegment = null; |
| if (component instanceof XSDElementDeclaration) |
| { |
| XSDElementDeclaration elementDeclaration = (XSDElementDeclaration) component; |
| pathSegment = new PathSegment(PathSegment.ELEMENT, elementDeclaration.getResolvedElementDeclaration().getName()); |
| } |
| else if (component instanceof XSDTypeDefinition) |
| { |
| XSDTypeDefinition typeDefinition = (XSDTypeDefinition) component; |
| pathSegment = new PathSegment(PathSegment.TYPE, typeDefinition.getName()); |
| } |
| else if (component instanceof XSDModelGroupDefinition) |
| { |
| XSDModelGroupDefinition modelGroupDefinition = (XSDModelGroupDefinition) component; |
| pathSegment = new PathSegment(PathSegment.MODEL_GROUP, modelGroupDefinition.getName()); |
| } |
| else if (component instanceof XSDAttributeGroupDefinition) |
| { |
| XSDAttributeGroupDefinition attributeGroupDefinition = (XSDAttributeGroupDefinition) component; |
| pathSegment = new PathSegment(PathSegment.ATTRIBUTE_GROUP, attributeGroupDefinition.getResolvedAttributeGroupDefinition().getName()); |
| } |
| else if (component instanceof XSDRedefine) |
| { |
| XSDRedefine redefine = (XSDRedefine) component; |
| pathSegment = new PathSegment(PathSegment.REDEFINE, redefine.getSchemaLocation()); |
| } |
| return pathSegment; |
| } |
| |
| public String toString() |
| { |
| StringBuffer b = new StringBuffer(); |
| for (Iterator i = segments.iterator(); i.hasNext();) |
| { |
| PathSegment segment = (PathSegment) i.next(); |
| String kind = ""; |
| if (segment.kind == PathSegment.ELEMENT) |
| { |
| kind = ELEMENT_TOKEN; |
| } |
| else if (segment.kind == PathSegment.TYPE) |
| { |
| kind = TYPE_TOKEN; |
| } |
| else if (segment.kind == PathSegment.MODEL_GROUP) |
| { |
| kind = MODEL_GROUP_TOKEN; |
| } |
| else if (segment.kind == PathSegment.ATTRIBUTE_GROUP) |
| { |
| kind = ATTRIBUTE_GROUP_TOKEN; |
| } |
| else if (segment.kind == PathSegment.REDEFINE) |
| { |
| kind = REDEFINE_TOKEN; |
| } |
| b.append(kind); |
| if (segment.name != null) |
| { |
| b.append("[@name='" + segment.name + "']"); |
| } |
| if (i.hasNext()) |
| { |
| b.append("/"); |
| } |
| } |
| return b.toString(); |
| } |
| } |
| |
| |
| static class PathResolvingXSDVisitor extends XSDVisitor |
| { |
| Path path; |
| int index = -1; |
| PathSegment segment; |
| XSDConcreteComponent result = null; |
| |
| PathResolvingXSDVisitor(Path path) |
| { |
| this.path = path; |
| incrementSegment(); |
| } |
| |
| boolean isDone() |
| { |
| return index >= path.segments.size(); |
| } |
| |
| void incrementSegment() |
| { |
| index++; |
| if (index < path.segments.size()) |
| { |
| segment = (PathSegment) path.segments.get(index); |
| } |
| else |
| { |
| segment = null; |
| } |
| } |
| |
| public void visitSchema(XSDSchema schema) |
| { |
| if (segment != null) |
| { |
| if (segment.kind == PathSegment.ELEMENT) |
| { |
| XSDElementDeclaration elementDeclaration = schema.resolveElementDeclaration(segment.name); |
| if (elementDeclaration != null) |
| { |
| visitElementDeclaration(elementDeclaration); |
| } |
| } |
| else if (segment.kind == PathSegment.TYPE) |
| { |
| XSDTypeDefinition typeDefinition = schema.resolveTypeDefinition(segment.name); |
| if (typeDefinition != null) |
| { |
| visitTypeDefinition(typeDefinition); |
| } |
| } |
| else if (segment.kind == PathSegment.MODEL_GROUP) |
| { |
| XSDModelGroupDefinition modelGroupDefinition = schema.resolveModelGroupDefinition(segment.name); |
| if (modelGroupDefinition != null) |
| { |
| visitModelGroupDefinition(modelGroupDefinition); |
| } |
| } |
| else if (segment.kind == PathSegment.ATTRIBUTE_GROUP) |
| { |
| XSDAttributeGroupDefinition attributeGroupDefinition = schema.resolveAttributeGroupDefinition(segment.name); |
| if (attributeGroupDefinition != null) |
| { |
| visitAttributeGroupDefinition(attributeGroupDefinition); |
| } |
| } |
| else if (segment.kind == PathSegment.REDEFINE) |
| { |
| Iterator iterator = schema.getContents().iterator(); |
| while (iterator.hasNext()) |
| { |
| Object object = iterator.next(); |
| if (object instanceof XSDRedefine) |
| { |
| XSDRedefine redefine = (XSDRedefine)object; |
| visitRedefine(redefine); |
| } |
| } |
| } |
| } |
| } |
| |
| public void visitElementDeclaration(XSDElementDeclaration element) |
| { |
| if (segment != null) |
| { |
| String name = element.getResolvedElementDeclaration().getName(); |
| if (segment.kind == PathSegment.ELEMENT && isMatch(segment.name, name)) |
| { |
| result = element; |
| incrementSegment(); |
| if (!isDone()) |
| { |
| super.visitElementDeclaration(element); |
| } |
| } |
| } |
| } |
| |
| public void visitTypeDefinition(XSDTypeDefinition type) |
| { |
| if (segment != null) |
| { |
| String name = type.getName(); |
| if (segment.kind == PathSegment.TYPE && isMatch(segment.name, name)) |
| { |
| result = type; |
| incrementSegment(); |
| if (!isDone()) |
| { |
| super.visitTypeDefinition(type); |
| } |
| } |
| } |
| } |
| |
| public void visitModelGroupDefinition(XSDModelGroupDefinition modelGroup) |
| { |
| if (segment != null) |
| { |
| String name = modelGroup.getName(); |
| if (segment.kind == PathSegment.MODEL_GROUP && isMatch(segment.name, name)) |
| { |
| result = modelGroup; |
| incrementSegment(); |
| if (!isDone()) |
| { |
| super.visitModelGroupDefinition(modelGroup); |
| } |
| } |
| } |
| } |
| |
| public void visitAttributeGroupDefinition(XSDAttributeGroupDefinition attributeGroup) |
| { |
| if (segment != null) |
| { |
| String name = attributeGroup.getName(); |
| if (segment.kind == PathSegment.ATTRIBUTE_GROUP && isMatch(segment.name, name)) |
| { |
| result = attributeGroup; |
| incrementSegment(); |
| if (!isDone()) |
| { |
| super.visitAttributeGroupDefinition(attributeGroup); |
| } |
| } |
| } |
| } |
| |
| public void visitRedefine(XSDRedefine redefine) |
| { |
| if (segment != null) |
| { |
| String name = redefine.getSchemaLocation(); |
| if (segment.kind == PathSegment.REDEFINE && isMatch(segment.name, name)) |
| { |
| result = redefine; |
| incrementSegment(); |
| if (!isDone()) |
| { |
| visitSchema(redefine.getSchema()); |
| } |
| } |
| } |
| |
| } |
| protected boolean isMatch(String name1, String name2) |
| { |
| return name1 != null ? name1.equals(name2) : name1 == name2; |
| } |
| } |
| } |
