| /******************************************************************************* |
| * Copyright (c) 2001, 2004 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.graph.editparts; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.List; |
| |
| import org.eclipse.draw2d.ColorConstants; |
| import org.eclipse.draw2d.Label; |
| import org.eclipse.draw2d.LineBorder; |
| import org.eclipse.draw2d.MarginBorder; |
| import org.eclipse.draw2d.RectangleFigure; |
| import org.eclipse.draw2d.geometry.Point; |
| import org.eclipse.gef.EditPart; |
| import org.eclipse.gef.EditPolicy; |
| import org.eclipse.gef.Request; |
| import org.eclipse.gef.RequestConstants; |
| import org.eclipse.gef.requests.LocationRequest; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.wst.xsd.ui.internal.XSDEditorPlugin; |
| import org.eclipse.wst.xsd.ui.internal.gef.util.figures.SpacingFigure; |
| import org.eclipse.wst.xsd.ui.internal.graph.XSDChildUtility; |
| import org.eclipse.wst.xsd.ui.internal.graph.XSDGraphUtil; |
| import org.eclipse.wst.xsd.ui.internal.graph.XSDSubstitutionGroupChildUtility; |
| import org.eclipse.wst.xsd.ui.internal.graph.XSDSubstitutionGroupsViewer; |
| import org.eclipse.wst.xsd.ui.internal.graph.editpolicies.ComboBoxCellEditorManager; |
| import org.eclipse.wst.xsd.ui.internal.graph.editpolicies.ComponentNameDirectEditManager; |
| import org.eclipse.wst.xsd.ui.internal.graph.editpolicies.SimpleDirectEditPolicy; |
| import org.eclipse.wst.xsd.ui.internal.graph.editpolicies.TypeReferenceDirectEditManager; |
| import org.eclipse.wst.xsd.ui.internal.graph.figures.ContainerFigure; |
| import org.eclipse.wst.xsd.ui.internal.graph.figures.ExpandableGraphNodeFigure; |
| import org.eclipse.wst.xsd.ui.internal.graph.figures.FillLayout; |
| import org.eclipse.wst.xsd.ui.internal.graph.figures.GraphNodeFigure; |
| import org.eclipse.wst.xsd.ui.internal.graph.model.XSDModelAdapterFactory; |
| import org.eclipse.wst.xsd.ui.internal.util.TypesHelper; |
| import org.eclipse.xsd.XSDComplexTypeDefinition; |
| import org.eclipse.xsd.XSDElementDeclaration; |
| import org.eclipse.xsd.XSDParticle; |
| import org.eclipse.xsd.XSDSchema; |
| import org.eclipse.xsd.XSDSimpleTypeDefinition; |
| import org.eclipse.xsd.XSDTypeDefinition; |
| |
| |
| |
| public class ElementDeclarationEditPart extends ExpandableGraphNodeEditPart |
| { |
| public Label label; |
| protected Label contentIconLabel; |
| protected Label typeValueLabel; |
| protected SimpleDirectEditPolicy simpleDirectEditPolicy = new SimpleDirectEditPolicy(); |
| protected boolean isContentIconLabelSelected = false; |
| |
| protected final static String ELEMENT_TYPE_PLACE_HOLDER = "ELEMENT_TYPE_PLACE_HOLDER"; |
| |
| public XSDParticle getXSDParticle() |
| { |
| Object o = getXSDElementDeclaration().getContainer(); |
| return (o instanceof XSDParticle) ? (XSDParticle)o : null; |
| } |
| |
| public XSDElementDeclaration getXSDElementDeclaration() |
| { |
| return (XSDElementDeclaration)getModel(); |
| } |
| |
| protected boolean isDefaultExpanded() |
| { |
| // hack to expand up to its content. The previous test didn't appear to work |
| int depth = 0; |
| for (EditPart part = this; part != null; part = part.getParent()) |
| { |
| depth++; |
| } |
| return depth <= 3; |
| } |
| |
| protected GraphNodeFigure createGraphNodeFigure() |
| { |
| ExpandableGraphNodeFigure figure = new ExpandableGraphNodeFigure(); |
| |
| figure.getOutlinedArea().setFill(true); |
| figure.getOutlinedArea().setLayoutManager(new FillLayout()); |
| |
| label = new Label(); |
| figure.getIconArea().add(label); |
| label.setFont(mediumBoldFont); |
| |
| SpacingFigure spacingFigure = new SpacingFigure(); |
| figure.getIconArea().add(spacingFigure); |
| |
| contentIconLabel = new Label(); |
| //contentIcon.setBorder(new MarginBorder(2, 2, 2, 10)); |
| figure.getIconArea().add(contentIconLabel); |
| |
| // A sneaky null check.... getViewer() does a getRoot(), but getRoot() might be null |
| // same with getParent() |
| if (getParent() != null && getRoot() != null && getViewer() instanceof XSDSubstitutionGroupsViewer) |
| { |
| figure.getOuterContentArea().getContainerLayout().setSpacing(5); |
| } |
| else |
| { |
| RectangleFigure line = new RectangleFigure(); |
| line.setPreferredSize(20, 1); |
| figure.getOutlinedArea().add(line, 1); |
| |
| figure.getInnerContentArea().setLayoutManager(new FillLayout(2)); |
| figure.getInnerContentArea().setBorder(new MarginBorder(2,2,2,1)); |
| |
| ContainerFigure labelGroup = new ContainerFigure(); |
| Label typeLabel = new Label("type"); |
| labelGroup.add(typeLabel); |
| labelGroup.setBorder(new MarginBorder(0, 4, 0, 4)); |
| |
| Label equalsLabel = new Label(" = "); |
| labelGroup.add(equalsLabel); |
| |
| typeValueLabel = new Label(); |
| labelGroup.add(typeValueLabel); |
| figure.getOutlinedArea().add(labelGroup, 2); |
| } |
| return figure; |
| } |
| |
| protected ExpandableGraphNodeFigure getExpandableGraphNodeFigure() |
| { |
| return (ExpandableGraphNodeFigure)graphNodeFigure; |
| } |
| |
| protected List getModelChildren() |
| { |
| return getExpandableGraphNodeFigure().isExpanded() ? getModelChildrenHelper() : Collections.EMPTY_LIST; |
| } |
| |
| protected List getModelChildrenHelper() |
| { |
| if (getViewer() instanceof XSDSubstitutionGroupsViewer) |
| { |
| return XSDSubstitutionGroupChildUtility.getModelChildren(getXSDElementDeclaration().getResolvedElementDeclaration()); |
| } |
| else |
| { |
| return XSDChildUtility.getModelChildren(getXSDElementDeclaration().getResolvedElementDeclaration()); |
| } |
| } |
| |
| protected void refreshContentIcon() |
| { |
| String iconName = null; |
| XSDTypeDefinition td = getXSDElementDeclaration().getResolvedElementDeclaration().getTypeDefinition(); |
| if (td instanceof XSDSimpleTypeDefinition) |
| { |
| // TODO... we should probably show the overlay form of this icon in the case that its a |
| // restriction, list or union |
| iconName = "icons/XSDSimpleType.gif"; |
| } |
| else if (td instanceof XSDComplexTypeDefinition) |
| { |
| XSDComplexTypeDefinition complexTypeDefinition = (XSDComplexTypeDefinition)td; |
| if (complexTypeDefinition.getAttributeUses().size() > 0) |
| { |
| iconName = "icons/XSDAttribute.gif"; |
| } |
| } |
| Image image = iconName != null ? XSDEditorPlugin.getXSDImage(iconName) : null; |
| contentIconLabel.setIcon(image); |
| } |
| |
| protected void refreshVisuals() |
| { |
| String text = getXSDElementDeclaration().isElementDeclarationReference() ? |
| getXSDElementDeclaration().getResolvedElementDeclaration().getQName(getXSDElementDeclaration().getSchema()) : |
| getXSDElementDeclaration().getName(); |
| |
| label.setText(text); |
| |
| |
| ContainerFigure rectangle = graphNodeFigure.getOutlinedArea(); |
| if (XSDGraphUtil.isEditable(getXSDElementDeclaration())) |
| { |
| rectangle.setBorder(new LineBorder(isSelected ? ColorConstants.black : elementBorderColor, 2)); |
| rectangle.setBackgroundColor(elementBackgroundColor); |
| rectangle.setForegroundColor(elementBorderColor); |
| graphNodeFigure.getInnerContentArea().setForegroundColor(ColorConstants.black); |
| if (XSDGraphUtil.isEditable(getXSDElementDeclaration().getResolvedElementDeclaration())) |
| { |
| // give label 'editable' colour |
| graphNodeFigure.getInnerContentArea().setForegroundColor(elementLabelColor); |
| } |
| else |
| { |
| // give label 'read only' colour |
| graphNodeFigure.getInnerContentArea().setForegroundColor(elementBorderColor); |
| } |
| label.setBackgroundColor(elementBackgroundColor); |
| label.setForegroundColor(elementLabelColor); |
| } |
| else |
| { |
| rectangle.setBorder(new LineBorder(isSelected ? ColorConstants.black : readOnlyBorderColor, 2)); |
| rectangle.setBackgroundColor(readOnlyBackgroundColor); |
| rectangle.setForegroundColor(readOnlyBorderColor); |
| graphNodeFigure.getInnerContentArea().setForegroundColor(readOnlyBorderColor); |
| label.setBackgroundColor(readOnlyBackgroundColor); |
| } |
| |
| if (getXSDElementDeclaration().isElementDeclarationReference()) |
| { |
| label.setIcon(XSDEditorPlugin.getXSDImage("icons/GraphViewElementRef.gif")); |
| label.setBorder(new MarginBorder(0, 0, 0, 4)); |
| } |
| else |
| { |
| label.setIcon(null); |
| label.setBorder(new MarginBorder(0, 6, 0, 4)); |
| } |
| |
| if (getXSDParticle() != null) |
| { |
| refreshOccurenceLabel(getXSDParticle().getMinOccurs(), getXSDParticle().getMaxOccurs()); |
| } |
| |
| |
| if (typeValueLabel != null) |
| { |
| XSDElementDeclaration ed = getXSDElementDeclaration(); |
| if (ed.getElement() != null) |
| { |
| String type = ed.getElement().getAttribute("type"); |
| if (type == null) |
| { |
| type = ""; |
| } |
| if (!getXSDElementDeclaration().isElementDeclarationReference()) |
| { |
| typeValueLabel.setText(type.equals("") ? "<anonymous>" : type); |
| } |
| else // if it is a ref, we show the resolved type |
| { |
| String resolvedType = ""; |
| if (ed.getResolvedElementDeclaration() != null) |
| { |
| if (ed.getResolvedElementDeclaration().getTypeDefinition() != null) |
| { |
| resolvedType = ed.getResolvedElementDeclaration().getTypeDefinition().getQName(ed.getSchema()); |
| |
| // if null, it has an anonymous type that has no resolved type |
| if (resolvedType == null) |
| { |
| resolvedType = "<anonymous>"; |
| } |
| } |
| } |
| typeValueLabel.setText(resolvedType); |
| } |
| } |
| } |
| refreshContentIcon(); |
| } |
| |
| |
| public void performRequest(Request request) |
| { |
| if (request.getType() == RequestConstants.REQ_DIRECT_EDIT || |
| request.getType() == RequestConstants.REQ_OPEN) |
| { |
| if (XSDGraphUtil.isEditable(getXSDElementDeclaration())) |
| { |
| if (request instanceof LocationRequest) |
| { |
| LocationRequest locationRequest = (LocationRequest)request; |
| Point p = locationRequest.getLocation(); |
| isContentIconLabelSelected = false; |
| |
| if (hitTest(label, p)) |
| { |
| performDirectEditForLabel(); |
| } |
| else if (hitTest(typeValueLabel, p)) |
| { |
| performDirectEditForTypeValueLabel(); |
| } |
| } |
| } |
| } |
| } |
| |
| private void performDirectEditForTypeValueLabel() |
| { |
| if (!getXSDElementDeclaration().isElementDeclarationReference()) |
| { |
| TypeReferenceDirectEditManager manager = new TypeReferenceDirectEditManager(this, getXSDElementDeclaration(), typeValueLabel); |
| simpleDirectEditPolicy.setDelegate(manager); |
| manager.show(); |
| } |
| // just ignore type edit for element ref's |
| } |
| |
| |
| private void performDirectEditForLabel() |
| { |
| if (getXSDElementDeclaration().isElementDeclarationReference()) |
| { |
| ComboBoxCellEditorManager manager = new ComboBoxCellEditorManager(this, label) |
| { |
| protected List computeComboContent() |
| { |
| XSDSchema schema = getXSDElementDeclaration().getSchema(); |
| List globalElementNameList = new ArrayList(); |
| if (schema != null) |
| { |
| TypesHelper typesHelper = new TypesHelper(schema); |
| globalElementNameList = typesHelper.getGlobalElements(); |
| } |
| return globalElementNameList; |
| } |
| |
| public void performModify(String value) |
| { |
| getXSDElementDeclaration().getElement().setAttribute("ref", value); |
| } |
| }; |
| simpleDirectEditPolicy.setDelegate(manager); |
| manager.show(); |
| } |
| else |
| { |
| ComponentNameDirectEditManager manager = new ComponentNameDirectEditManager(this, label, getXSDElementDeclaration()); |
| simpleDirectEditPolicy.setDelegate(manager); |
| manager.show(); |
| } |
| } |
| |
| |
| protected void createEditPolicies() |
| { |
| super.createEditPolicies(); |
| installEditPolicy(EditPolicy.DIRECT_EDIT_ROLE, simpleDirectEditPolicy); |
| } |
| |
| |
| public void activate() |
| { |
| super.activate(); |
| if (getXSDParticle() != null) |
| { |
| XSDModelAdapterFactory.addModelAdapterListener(getXSDParticle(), this); |
| } |
| } |
| /** |
| * Apart from the deactivation done in super, the source |
| * and target connections are deactivated, and the visual |
| * part of the this is removed. |
| * |
| * @see #activate() |
| */ |
| public void deactivate() |
| { |
| if (getXSDParticle() != null) |
| { |
| XSDModelAdapterFactory.removeModelAdapterListener(getXSDParticle(), this); |
| } |
| super.deactivate(); |
| } |
| |
| public boolean isContentIconLabelSelected() |
| { |
| return isContentIconLabelSelected; |
| } |
| } |
