Attachment #213179 for bug #334142

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.graphiti.mm.pictograms.Shape;
import org.eclipse.jpt.jpa.core.JpaProject;
import org.eclipse.jpt.jpa.core.MappingKeys;
import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
import org.eclipse.jpt.jpa.core.context.persistence.ClassRef;
import org.eclipse.jpt.jpa.core.context.persistence.PersistenceUnit;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.i18n.JPAEditorMessages;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.modelintegration.util.ModelIntegrationUtil;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorConstants;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;


public class AddAllEntitiesFeature extends AbstractCustomFeature implements IAddFeature {

		numInARow = (numInARow > 0) ? numInARow : 1;
		
		lowerEdges[0] = lowestRightestPointOfExistingDiagram.y + ((lowestRightestPointOfExistingDiagram.y == 0) ? DIST_FROM_EDGE_V : DIST_V);		
		TransactionalEditingDomain ted = ModelIntegrationUtil.getTransactionalEditingDomain(d);
		
		for (ClassRef classRef : unit.getClassRefs()) {
			if (classRef.getJavaPersistentType() != null) { // null if
				JavaPersistentType jpt = classRef.getJavaPersistentType(); 
				if (JpaArtifactFactory.instance().hasEntityOrMappedSuperclassAnnotation(jpt)) {
					PictogramElement pe = getFeatureProvider().getPictogramElementForBusinessObject(jpt);
					if (pe != null)
						continue;

					
					int x = DIST_FROM_EDGE_H + ie.index * (JPAEditorConstants.ENTITY_WIDTH + DIST_H);
					ctx.setLocation(x, ie.lowerEdge);
					final AddJPAEntityFeature ft = new AddJPAEntityFeature(getFeatureProvider(), false);
					
					final Diagram targetDiagram = (Diagram) ctx.getTargetContainer();
					TransactionalEditingDomain ted = ModelIntegrationUtil.getTransactionalEditingDomain(targetDiagram);
					ted.getCommandStack().execute(new RecordingCommand(ted) {
						@Override
						protected void doExecute() {

				}
			}
		}		
		ted.getCommandStack().execute(new RecordingCommand(ted) {
			@Override
			protected void doExecute() {
				JpaArtifactFactory.instance().rearrangeIsARelations(getFeatureProvider());
			}
		});

	}
	
	private IndexAndLowerEdge getMinLowerEdge() {

		return JPAEditorMessages.JPAEditorToolBehaviorProvider_showAllTheEntities;
	}
	
	public IJPAEditorFeatureProvider getFeatureProvider() {
		return (IJPAEditorFeatureProvider) super.getFeatureProvider();
	}

	
}




/*******************************************************************************
 * <copyright>
 *
 * Copyright (c) 2005, 2010 SAP AG.
 * 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:
 *    Stefan Dimov - initial API, implementation and documentation
 *
 * </copyright>
 *
 *******************************************************************************/
package org.eclipse.jpt.jpadiagrameditor.ui.internal.feature;

import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.IAddConnectionContext;
import org.eclipse.graphiti.features.context.IAddContext;
import org.eclipse.graphiti.features.impl.AbstractAddFeature;
import org.eclipse.graphiti.mm.pictograms.ConnectionDecorator;
import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.graphiti.mm.pictograms.FreeFormConnection;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.graphiti.services.Graphiti;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorImageCreator;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.JPAEditorImageCreator;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IsARelation;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.IJPAEditorUtil;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorUtilImpl;

public class AddInheritedEntityFeature extends AbstractAddFeature {

	private IJPAEditorImageCreator imageCreator;
	
	public AddInheritedEntityFeature(IFeatureProvider fp) {
		this(fp, new JPAEditorImageCreator(), new JPAEditorUtilImpl());
	}
	

	public AddInheritedEntityFeature(IFeatureProvider fp,
		  IJPAEditorImageCreator imageCreator, 
		  IJPAEditorUtil jpaEditorUtil) {
		super(fp);
		this.imageCreator = imageCreator;
	}
	
	
	public boolean canAdd(IAddContext context) {
		return true;
	}

	public PictogramElement add(IAddContext context) {
        final IAddConnectionContext addConContext = (IAddConnectionContext) context;
		final IsARelation relation = (IsARelation)context.getNewObject();
		final Diagram diagram = getDiagram();
		FreeFormConnection connection = createIsAConnection(addConContext, relation, diagram);
		imageCreator.createIsAConnectionLine(diagram, connection);
		layoutPictogramElement(connection);
		return connection;	
	}
	
	private FreeFormConnection createIsAConnection(IAddConnectionContext addConContext, IsARelation relation,
			final Diagram diagram) {
		FreeFormConnection connection = getFeatureProvider().getPeService().createFreeFormConnection(diagram);
        connection.setStart(addConContext.getSourceAnchor());
        connection.setEnd(addConContext.getTargetAnchor());
        connection.setVisible(true);
        connection.setActive(true);
        getFeatureProvider().getPeServiceUtil().setPropertyValue(connection, IsARelation.IS_A_CONNECTION_PROP_KEY, Boolean.TRUE.toString());
        addDecorators(connection);
		return connection;
	}
	
	public IJPAEditorFeatureProvider getFeatureProvider() {
		return (IJPAEditorFeatureProvider)super.getFeatureProvider();
	}
	
	private void addDecorators(FreeFormConnection c) {
		ConnectionDecorator d = imageCreator.createArrowConnectionDecorator(c, 0.9999, true);
		Graphiti.getGaService().setLocation(d.getGraphicsAlgorithm(), 0, 0);
	}
	
}




import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;

import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.IAddContext;
import org.eclipse.graphiti.features.context.ICreateContext;
import org.eclipse.graphiti.features.context.impl.CreateContext;
import org.eclipse.graphiti.features.impl.AbstractAddShapeFeature;
import org.eclipse.graphiti.mm.algorithms.Image;
import org.eclipse.graphiti.mm.algorithms.Polyline;

import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.graphiti.mm.pictograms.Shape;
import org.eclipse.graphiti.services.Graphiti;
import org.eclipse.graphiti.util.IColorConstant;
import org.eclipse.graphiti.util.PredefinedColoredAreas;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IPackageDeclaration;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.core.SourceType;
import org.eclipse.jpt.jpa.core.JpaProject;
import org.eclipse.jpt.jpa.core.context.AttributeMapping;
import org.eclipse.jpt.jpa.core.context.java.JavaMappedSuperclass;
import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.JPADiagramEditorPlugin;

import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.JPAEditorImageProvider;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.GraphicsUpdater;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorConstants;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorConstants.ShapeType;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorPredefinedColoredAreas;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorUtil;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorConstants.ShapeType;


@SuppressWarnings({ "restriction" })
public class AddJPAEntityFeature extends AbstractAddShapeFeature {

	private IPeUtilFacade facade;
	private boolean shouldRearrangeIsARelations = true;
	private static ContainerShape primaryShape;
	private static ContainerShape relationShape;
	private static ContainerShape basicShape;


	public AddJPAEntityFeature(IFeatureProvider fp, boolean shouldRearrangeIsARelations) {
		super(fp);
		this.shouldRearrangeIsARelations = shouldRearrangeIsARelations;
		facade = new PeUtilFacade();
	}


		JavaPersistentType jpt = null;
		if (newObj instanceof JavaPersistentType) {
			jpt = (JavaPersistentType) newObj;
			if (jpt.getMapping() instanceof JavaMappedSuperclass) {
				jpt = createEntityFromExistingMappedSuperclass(fp, jpt);
			}			
		} else if (newObj instanceof ICompilationUnit) {
			ICompilationUnit cu = (ICompilationUnit) newObj;
			jpt = JPAEditorUtil.getJPType(cu);
			if (jpt.getMapping() instanceof JavaMappedSuperclass) {
				jpt = createEntityFromExistingMappedSuperclass(fp, jpt);
			}

		} else if (newObj instanceof SourceType) {
			ICompilationUnit cu = ((SourceType)newObj).getCompilationUnit();

				
	    ContainerShape entityShape = facade.createContainerShape(targetDiagram, true);
		
	    JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot = JpaArtifactFactory.instance().determineDiagramObjectType(jpt);
		createEntityRectangle(context, entityShape, dot,
							  this.getFeatureProvider().getDiagramTypeProvider().getDiagram());
		link(entityShape, jpt);
		Shape shape = Graphiti.getPeService().createShape(entityShape, false);
		Polyline headerBottomLine = Graphiti.getGaService().createPolyline(shape, new int[] { 0,

				.setForeground(manageColor(JPAEditorConstants.ENTITY_BORDER_COLOR));
		headerBottomLine.setLineWidth(JPAEditorConstants.ENTITY_BORDER_WIDTH);

		addHeader(jpt, entityShape, JPAEditorConstants.ENTITY_WIDTH, dot);
		
		createCompartments(context, jpt, entityShape);
		fillCompartments(jpt,entityShape);


		UpdateAttributeFeature updateFeature = new UpdateAttributeFeature(fp);
		updateFeature.reconnect(jpt);
		if (shouldRearrangeIsARelations)
			JpaArtifactFactory.instance().rearrangeIsARelations(getFeatureProvider());	
		return entityShape;
	}

	private JavaPersistentType createEntityFromExistingMappedSuperclass(
			IJPAEditorFeatureProvider fp, JavaPersistentType jpt) {
		ICreateContext cont = new CreateContext();
		String packageName = null;
		try {
			packageName = getMappedSuperclassPackageDeclaration(fp, jpt,
					packageName);
		} catch (JavaModelException e) {
			JPADiagramEditorPlugin.logError(e); 	     					
		}

		boolean hasPrimaryKey = hasMappedSuperclassPrimaryKeyAttribute(jpt);

		CreateJPAEntityFeature createFeature = new CreateJPAEntityFeature(fp,
				true, jpt.getName(), packageName, hasPrimaryKey);
		Object[] objects = createFeature.create(cont);
		if (objects.length != 0) {
			Object obj = objects[0];
			if (obj instanceof JavaPersistentType) {
				jpt = (JavaPersistentType) obj;
			}
		}
		return jpt;
	}

	private boolean hasMappedSuperclassPrimaryKeyAttribute(
			JavaPersistentType jpt) {
		
		for (AttributeMapping map : ((JavaMappedSuperclass) jpt.getMapping()).getAllAttributeMappings()) {
			if (map.getPrimaryKeyColumnName() != null) {
				return true;
			}
		}
		return false;
	}

	private String getMappedSuperclassPackageDeclaration(
			IJPAEditorFeatureProvider fp, JavaPersistentType jpt,
			String packageName) throws JavaModelException {
		IPackageDeclaration[] packages = fp.getCompilationUnit(jpt)
				.getPackageDeclarations();
		if (packages.length > 0) {
			IPackageDeclaration packageDecl = packages[0];
			packageName = packageDecl.getElementName();
		}
		return packageName;
	}
	
	private void createCompartments(IAddContext context, JavaPersistentType jpt,
			ContainerShape entityShape) {
		JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot = JpaArtifactFactory.instance().determineDiagramObjectType(jpt);
		primaryShape = createCompartmentRectangle(entityShape, 
												  JPAEditorConstants.ENTITY_MIN_HEIGHT, 
												  JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape,
												  dot);
		relationShape = createCompartmentRectangle(entityShape, 
												   GraphicsUpdater.getNextCompartmentY(primaryShape) + JPAEditorConstants.SEPARATOR_HEIGHT,
												   JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes,
												   dot);
		basicShape = createCompartmentRectangle(entityShape, 
												GraphicsUpdater.getNextCompartmentY(relationShape) + JPAEditorConstants.SEPARATOR_HEIGHT, 
												JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
												dot);
		if (IAddEntityContext.class.isInstance(context)) {
			IAddEntityContext entityContext = (IAddEntityContext) context;
			GraphicsUpdater.setCollapsed(primaryShape, entityContext.isPrimaryCollapsed());

	}

	private ContainerShape createCompartmentRectangle(
			ContainerShape entityShape, int y, String attribTxt,
			JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot) {
		int width = entityShape.getGraphicsAlgorithm().getWidth();
		ContainerShape containerShape = Graphiti.getPeService().createContainerShape(
				entityShape, false);

		
		UpdateAttributeFeature updateFeature = new UpdateAttributeFeature(getFeatureProvider());
		
		updateFeature.addSeparatorsToShape(containerShape, dot);
		
		return containerShape;
	}

	}

	public static RoundedRectangle createEntityRectangle(IAddContext context,
														 ContainerShape entityShape, 
														 JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot,  
														 Diagram diagram) {

		IColorConstant foreground = JpaArtifactFactory.instance().getForeground(dot);
		IColorConstant background = JpaArtifactFactory.instance().getBackground(dot);
		String renderingStyle = JpaArtifactFactory.instance().getRenderingStyle(dot);
		
		RoundedRectangle entityRectangle = Graphiti.getGaService().createRoundedRectangle(
				entityShape, JPAEditorConstants.ENTITY_CORNER_WIDTH,
				JPAEditorConstants.ENTITY_CORNER_HEIGHT);
		entityRectangle
				.setForeground(Graphiti.getGaService().manageColor(diagram, foreground));
		entityRectangle
				.setBackground(Graphiti.getGaService().manageColor(diagram, background));
		Graphiti.getGaService().setRenderingStyle(entityRectangle.getPictogramElement().getGraphicsAlgorithm(), 
				JPAEditorPredefinedColoredAreas.getAdaptedGradientColoredAreas(renderingStyle));
		entityRectangle.setLineWidth(JPAEditorConstants.ENTITY_BORDER_WIDTH);
		entityRectangle.setLineStyle(LineStyle.SOLID);
		Graphiti.getGaService().setLocationAndSize(entityRectangle, context

	}

	private ContainerShape addHeader(JavaPersistentType addedWrapper,
									 ContainerShape entityShape, 
									 int width,
									 JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot) {
		String entityIconId = dot.equals(JPAEditorConstants.DIAGRAM_OBJECT_TYPE.Entity) ? 
									JPAEditorImageProvider.JPA_ENTITY :
									JPAEditorImageProvider.MAPPED_SUPERCLASS;
		
		ContainerShape headerIconShape = Graphiti.getPeService().createContainerShape(
				entityShape, false);
		Rectangle iconRect = Graphiti.getGaService().createRectangle(headerIconShape);

		iconRect.setHeight(JPAEditorConstants.HEADER_ICON_RECT_HEIGHT);
		iconRect.setY(0);
		Image headerIcon = Graphiti.getGaService().createImage(iconRect,
				entityIconId);
		Graphiti.getGaService().setLocationAndSize(headerIcon, 
													JPAEditorConstants.ICON_HEADER_X,
													JPAEditorConstants.ICON_HEADER_Y,




        
	private FreeFormConnection createConnection(IAddConnectionContext addConContext, IRelation relation,
			final Diagram diagram) {
        FreeFormConnection connection = getFeatureProvider().getPeServiceUtil().createFreeFormConnection(diagram);
        connection.setStart(addConContext.getSourceAnchor());
        connection.setEnd(addConContext.getTargetAnchor());
        connection.setVisible(true);

		double endCoefficient = 1.0 - startCoefficient;	
		int len = JPAEditorUtil.calcConnectionLength(c);		
		if (UNI.equals(direction)) {
			ConnectionDecorator d = imageCreator.createArrowConnectionDecorator(c, endCoefficient, false);
			Graphiti.getGaService().setLocation(d.getGraphicsAlgorithm(),Math.round(-len/10), 0);				
		} 
	}

		ConnectionDecorator d1 = imageCreator.createManyStartDecorator(c, startCoefficient);
		Graphiti.getGaService().setLocation(d1.getGraphicsAlgorithm(),Math.round(len/10), 0);
		if (UNI.equals(direction)) {
			ConnectionDecorator d2 = imageCreator.createArrowConnectionDecorator(c, endCoefficient, false);
			Graphiti.getGaService().setLocation(d2.getGraphicsAlgorithm(),Math.round(-len/10), 0);
		} 
    }




/*******************************************************************************
 * <copyright>
 *
 * Copyright (c) 2005, 2010 SAP AG.
 * 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:
 *    Stefan Dimov - initial API, implementation and documentation
 *
 * </copyright>
 *
 *******************************************************************************/
package org.eclipse.jpt.jpadiagrameditor.ui.internal.feature;

import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.ICreateConnectionContext;
import org.eclipse.graphiti.features.context.ICreateContext;
import org.eclipse.graphiti.features.context.impl.AddContext;
import org.eclipse.graphiti.features.context.impl.CreateContext;
import org.eclipse.graphiti.features.impl.AbstractCreateConnectionFeature;
import org.eclipse.graphiti.mm.pictograms.Anchor;
import org.eclipse.graphiti.mm.pictograms.Connection;
import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jpt.jpa.core.context.PersistentType;
import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.JPADiagramEditorPlugin;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.i18n.JPAEditorMessages;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.JPAEditorImageProvider;

public class CreateInheritedEntityFeature extends AbstractCreateConnectionFeature {

	public CreateInheritedEntityFeature(IFeatureProvider fp) {
		this(fp, JPAEditorMessages.CreateIsARelationFeature_name,	JPAEditorMessages.CreateIsARelationFeature_description);
	}
		
	public CreateInheritedEntityFeature(IFeatureProvider fp, String name,
			String description) {
		super(fp, name, description);
	}

	public boolean canCreate(ICreateConnectionContext context) {
		JavaPersistentType superclass = (JavaPersistentType)getPersistentType(context.getSourceAnchor());
	    if (superclass == null)
	    	return false;
	    if (context.getTargetAnchor() == null)
	    	return true;
		if (context.getTargetAnchor().getParent() instanceof Diagram)
			return true;
	    return false;
	}

	public Connection create(ICreateConnectionContext context) {
		JavaPersistentType mappedSuperclass = (JavaPersistentType)getPersistentType(context.getSourceAnchor());
		CreateJPAEntityFeature createEntityFeature = null;
		try {
			createEntityFeature = new CreateJPAEntityFeature(
					getFeatureProvider(), mappedSuperclass);
		} catch (JavaModelException e) {
			JPADiagramEditorPlugin.logError("Cannot create a new JPA entity class", e); //$NON-NLS-1$	
			return null;
		}
		ICreateContext ctx = new CreateContext();
		Object[] res = createEntityFeature.create(ctx);
		JavaPersistentType newEntity = (JavaPersistentType)res[0];
		AddJPAEntityFeature ft = new AddJPAEntityFeature(getFeatureProvider(), true);
		AddContext cont = new AddContext();
		cont.setTargetContainer(getFeatureProvider().getDiagram());
		cont.setNewObject(newEntity);
		cont.setLocation(context.getTargetLocation().getX(), context.getTargetLocation().getY());
		ft.add(cont);		
		return null;
	}

	public boolean canStartConnection(ICreateConnectionContext context) {
		JavaPersistentType superclass = (JavaPersistentType)getPersistentType(context.getSourceAnchor()); 
	    if (superclass == null) 
	        return false;
	    return true;
	}
	
    public String getCreateImageId() {
        return JPAEditorImageProvider.ADD_INHERITED_ENTITY;
    }	
    
	protected PersistentType getPersistentType(Anchor anchor) {
	    if (anchor != null) {
	        Object refObject =
	            getBusinessObjectForPictogramElement(anchor.getParent());
	        if (refObject instanceof PersistentType) {
	            return (PersistentType) refObject;
	        }
	    }
	    return null;
	}
	
	public IJPAEditorFeatureProvider getFeatureProvider() {
		return (IJPAEditorFeatureProvider)super.getFeatureProvider(); 
	}


}




import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.graphiti.mm.pictograms.Shape;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jpt.jpa.core.JpaProject;

import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.JPAEditorImageProvider;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorUtil;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbenchSite;

	
	private IPreferenceStore jpaPreferenceStore = JPADiagramEditorPlugin.getDefault().getPreferenceStore();
	private boolean isMappedSuperclassChild;
	private JavaPersistentType mappedSuperclass;
	private String mappedSuperclassName;
	private String mappedSuperclassPackage;
	private boolean superHasPrimarykey;


	public CreateJPAEntityFeature(IFeatureProvider fp) {


	public CreateJPAEntityFeature(IFeatureProvider fp,
			boolean isMappedSuperclassChild, String mappedSuperclassName,
			String mappedSuperClassPackage, boolean superHasPrimaryKey) {
		this(fp);
		this.isMappedSuperclassChild = isMappedSuperclassChild;
		this.mappedSuperclassName = mappedSuperclassName;
		this.mappedSuperclassPackage = mappedSuperClassPackage;
		this.superHasPrimarykey = superHasPrimaryKey;
	}

	public CreateJPAEntityFeature(IJPAEditorFeatureProvider fp,
			JavaPersistentType mappedSuperclass) throws JavaModelException {
		this(fp);
		this.isMappedSuperclassChild = true;
		this.mappedSuperclass = mappedSuperclass; 
		this.mappedSuperclassName = mappedSuperclass.getName();
		this.mappedSuperclassPackage = JpaArtifactFactory.instance().getMappedSuperclassPackageDeclaration(mappedSuperclass);
		this.superHasPrimarykey = JpaArtifactFactory.instance().hasOrInheritsPrimaryKey(mappedSuperclass);
	}
	

    public boolean canCreate(ICreateContext context) {
        return context.getTargetContainer() instanceof Diagram;

		}
		
		try {
			if (mappedSuperclass != null) {
				this.getFeatureProvider().
				getJPAEditorUtil().
					createEntityInProject(targetProject, entityName, mappedSuperclass);	//$NON-NLS-1$								
			} else {
				this.getFeatureProvider().
				getJPAEditorUtil().
					createEntityInProject(targetProject, entityName, jpaPreferenceStore, 
										  isMappedSuperclassChild, mappedSuperclassName, 
										  mappedSuperclassPackage, "id", superHasPrimarykey);	//$NON-NLS-1$				
			}
		} catch (Exception e1) {
			JPADiagramEditorPlugin.logError("Cannot create an entity in the project " + targetProject.getName(), e1);  //$NON-NLS-1$		 
		}

Lines 25-32 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateManyToManyBiDirRelationFeature.java (-2 / +2 lines)
25	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;	25	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
26		26
27		27
28	public class CreateManyToManyBiDirRelationFeature extends	28	public class CreateManyToManyBiDirRelationFeature extends CreateManyToManyRelationFeature
29	CreateManyToManyRelationFeature {	29	implements ICreateBiDirRelationFeature {
30		30
31	public CreateManyToManyBiDirRelationFeature(IJPAEditorFeatureProvider fp) {	31	public CreateManyToManyBiDirRelationFeature(IJPAEditorFeatureProvider fp) {
32	super(fp, JPAEditorMessages.CreateManyToManyBiDirRelationFeature_manyToManyBiDirFeatureName,	32	super(fp, JPAEditorMessages.CreateManyToManyBiDirRelationFeature_manyToManyBiDirFeatureName,

Lines 25-32 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateManyToManyUniDirRelationFeature.java (-2 / +2 lines)
25	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;	25	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
26		26
27		27
28	public class CreateManyToManyUniDirRelationFeature extends	28	public class CreateManyToManyUniDirRelationFeature extends CreateManyToManyRelationFeature
29	CreateManyToManyRelationFeature {	29	implements ICreateUniDirRelationFeature {
30		30
31	public CreateManyToManyUniDirRelationFeature(IJPAEditorFeatureProvider fp) {	31	public CreateManyToManyUniDirRelationFeature(IJPAEditorFeatureProvider fp) {
32	super(fp, JPAEditorMessages.CreateManyToManyUniDirRelationFeature_manyToManyUniDirFeatureName,	32	super(fp, JPAEditorMessages.CreateManyToManyUniDirRelationFeature_manyToManyUniDirFeatureName,

Lines 25-32 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateManyToOneBiDirRelationFeature.java (-2 / +2 lines)
25	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;	25	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
26		26
27		27
28	public class CreateManyToOneBiDirRelationFeature extends	28	public class CreateManyToOneBiDirRelationFeature extends CreateManyToOneRelationFeature
29	CreateManyToOneRelationFeature {	29	implements ICreateBiDirRelationFeature {
30		30
31	public CreateManyToOneBiDirRelationFeature(IJPAEditorFeatureProvider fp) {	31	public CreateManyToOneBiDirRelationFeature(IJPAEditorFeatureProvider fp) {
32	super(fp, JPAEditorMessages.CreateManyToOneBiDirRelationFeature_manyToOneBiDirFeatureName,	32	super(fp, JPAEditorMessages.CreateManyToOneBiDirRelationFeature_manyToOneBiDirFeatureName,

Lines 25-32 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateManyToOneUniDirRelationFeature.java (-2 / +2 lines)
25	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;	25	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
26		26
27		27
28	public class CreateManyToOneUniDirRelationFeature extends	28	public class CreateManyToOneUniDirRelationFeature extends CreateManyToOneRelationFeature
29	CreateManyToOneRelationFeature {	29	implements ICreateUniDirRelationFeature {
30		30
31	public CreateManyToOneUniDirRelationFeature(IJPAEditorFeatureProvider fp) {	31	public CreateManyToOneUniDirRelationFeature(IJPAEditorFeatureProvider fp) {
32	super(fp, JPAEditorMessages.CreateManyToOneUniDirRelationFeature_manyToOneUniDirFeatureName,	32	super(fp, JPAEditorMessages.CreateManyToOneUniDirRelationFeature_manyToOneUniDirFeatureName,




/*******************************************************************************
 * <copyright>
 *
 * Copyright (c) 2005, 2010 SAP AG.
 * 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:
 *    Stefan Dimov - initial API, implementation and documentation
 *
 * </copyright>
 *
 *******************************************************************************/
package org.eclipse.jpt.jpadiagrameditor.ui.internal.feature;

import java.util.List;

import org.eclipse.core.resources.IProject;
import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.ICreateContext;
import org.eclipse.graphiti.features.impl.AbstractCreateFeature;
import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.graphiti.mm.pictograms.Shape;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jpt.jpa.core.JpaProject;
import org.eclipse.jpt.jpa.core.JptJpaCorePlugin;
import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
import org.eclipse.jpt.jpa.core.context.persistence.PersistenceUnit;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.JPADiagramEditorPlugin;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.i18n.JPAEditorMessages;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.propertypage.JPADiagramPropertyPage;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.JPAEditorImageProvider;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorUtil;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbenchSite;
  


public class CreateMappedSuperclassFeature extends
		AbstractCreateFeature {

	public CreateMappedSuperclassFeature(IFeatureProvider fp) {
		super(
				fp,
				JPAEditorMessages.CreateMappedSuperclassFeature_createMappedSuperclassFeatureName,
				JPAEditorMessages.CreateMappedSuperclassFeature_createMappedSuperclassFeatureDescription);
	}

	public boolean canCreate(ICreateContext context) {
		return context.getTargetContainer() instanceof Diagram;
	}

	public Object[] create(ICreateContext context) {
		List<Shape> shapes = this.getFeatureProvider().getDiagramTypeProvider()
				.getDiagram().getChildren();
		IProject targetProject = null;
		JpaProject jpaProject = null;
		if ((shapes == null) || (shapes.size() == 0)) {
			jpaProject = getTargetJPAProject();
			targetProject = jpaProject.getProject();
		} else {
			Shape sh = shapes.get(0);
			JavaPersistentType jpt = (JavaPersistentType) getFeatureProvider()
					.getBusinessObjectForPictogramElement(sh);
			if (jpt == null)
				return new Object[] {};
			jpaProject = jpt.getJpaProject();
			targetProject = jpaProject.getProject();
		}
		
		String mappedSuperclassName = getFeatureProvider()
				.getJPAEditorUtil()
				.generateUniqueMappedSuperclassName(
						jpaProject,
						JPADiagramPropertyPage.getDefaultPackage(jpaProject.getProject()),
						getFeatureProvider());
		
		if (!JptJpaCorePlugin.getDiscoverAnnotatedClasses(jpaProject.getProject())) {
			JPAEditorUtil.createRegisterEntityInXMLJob(jpaProject, mappedSuperclassName);
		}
				
		try {
			getFeatureProvider().getJPAEditorUtil().createMappedSuperclassInProject(targetProject, mappedSuperclassName);
		} catch (Exception e1) {
			JPADiagramEditorPlugin.logError("Cannot create a mapped superclass in the project " + targetProject.getName(), e1);  //$NON-NLS-1$		 
		}
//		jpaProject.updateAndWait();
		PersistenceUnit pu = JpaArtifactFactory.instance().getPersistenceUnit(jpaProject);
		JavaPersistentType jpt = JpaArtifactFactory.instance().getJPT(mappedSuperclassName, pu);
		
		if (jpt != null) {
			addGraphicalRepresentation(context, jpt);
	        IWorkbenchSite ws = ((IEditorPart)getDiagramEditor()).getSite();
	        ICompilationUnit cu = getFeatureProvider().getCompilationUnit(jpt);
	        getFeatureProvider().getJPAEditorUtil().formatCode(cu, ws);			
			return new Object[] { jpt };
		} else {
			JPADiagramEditorPlugin.logError("The mapped superclass " + 						//$NON-NLS-1$
						mappedSuperclassName + " could not be created", new Exception());	//$NON-NLS-1$	 
		}				

		return new Object[] {};
	}

	public String getCreateImageId() {
		return JPAEditorImageProvider.ADD_MAPPED_SUPERCLASS;
	}


	public IJPAEditorFeatureProvider getFeatureProvider() {
		return (IJPAEditorFeatureProvider) super.getFeatureProvider();
	}

	private JpaProject getTargetJPAProject() {
		return getFeatureProvider().getMoinIntegrationUtil()
				.getProjectByDiagram(getDiagram());
	}

}

Lines 25-32 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateOneToManyUniDirRelationFeature.java (-2 / +2 lines)
25	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;	25	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
26		26
27		27
28	public class CreateOneToManyUniDirRelationFeature extends	28	public class CreateOneToManyUniDirRelationFeature extends CreateOneToManyRelationFeature
29	CreateOneToManyRelationFeature {	29	implements ICreateUniDirRelationFeature {
30		30
31	public CreateOneToManyUniDirRelationFeature(IJPAEditorFeatureProvider fp) {	31	public CreateOneToManyUniDirRelationFeature(IJPAEditorFeatureProvider fp) {
32	super(fp, JPAEditorMessages.CreateOneToManyUniDirRelationFeature_oneToManyUniDirFeatureName,	32	super(fp, JPAEditorMessages.CreateOneToManyUniDirRelationFeature_oneToManyUniDirFeatureName,

Lines 25-31 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateOneToOneBiDirRelationFeature.java (-1 / +2 lines)
25	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;	25	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
26		26
27		27
28	public class CreateOneToOneBiDirRelationFeature extends CreateOneToOneRelationFeature {	28	public class CreateOneToOneBiDirRelationFeature extends CreateOneToOneRelationFeature
		29	implements ICreateBiDirRelationFeature {
29		30
30	public CreateOneToOneBiDirRelationFeature(IJPAEditorFeatureProvider fp) {	31	public CreateOneToOneBiDirRelationFeature(IJPAEditorFeatureProvider fp) {
31	super(fp, JPAEditorMessages.CreateOneToOneBiDirRelationFeature_oneToOneBiDirFeatureName,	32	super(fp, JPAEditorMessages.CreateOneToOneBiDirRelationFeature_oneToOneBiDirFeatureName,

Lines 25-32 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateOneToOneUniDirRelationFeature.java (-2 / +2 lines)
25	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;	25	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
26		26
27		27
28		28	public class CreateOneToOneUniDirRelationFeature extends CreateOneToOneRelationFeature
29	public class CreateOneToOneUniDirRelationFeature extends CreateOneToOneRelationFeature {	29	implements ICreateUniDirRelationFeature {
30		30
31	public CreateOneToOneUniDirRelationFeature(IJPAEditorFeatureProvider fp) {	31	public CreateOneToOneUniDirRelationFeature(IJPAEditorFeatureProvider fp) {
32	super(fp, JPAEditorMessages.CreateOneToOneUniDirRelationFeature_oneToOneUniDirFeatureName,	32	super(fp, JPAEditorMessages.CreateOneToOneUniDirRelationFeature_oneToOneUniDirFeatureName,




import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.AbstractRelation;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;


abstract public class CreateRelationFeature extends AbstractCreateConnectionFeature {

	}

	public boolean canCreate(ICreateConnectionContext context) {
		JavaPersistentType owner = (JavaPersistentType)getPersistentType(context.getSourceAnchor());
		JavaPersistentType inverse = (JavaPersistentType)getPersistentType(context.getTargetAnchor());
	    if ((owner == null) || (inverse == null)) 
	        return false;
	    if (JpaArtifactFactory.instance().hasMappedSuperclassAnnotation(inverse))
	    	return false;
	    if ((this instanceof ICreateBiDirRelationFeature) && 
	    	(JpaArtifactFactory.instance().hasMappedSuperclassAnnotation(owner)))
	    	return false;
	    return true;
	}

	public boolean canStartConnection(ICreateConnectionContext context) {
		JavaPersistentType owner = (JavaPersistentType)getPersistentType(context.getSourceAnchor()); 
	    if (owner == null) 
	        return false;
	    if ((this instanceof ICreateBiDirRelationFeature) &&
	    	JpaArtifactFactory.instance().hasMappedSuperclassAnnotation(owner))
	    	return false;
	    return true;
	}
	
	public Connection create(ICreateConnectionContext context) {
	    Connection newConnection = null;
	    PersistentType owner = getPersistentType(context.getSourceAnchor());
	    PersistentType inverse = getPersistentType(context.getTargetAnchor());
	    if (owner != null && inverse != null) {
	    	AbstractRelation rel = createRelation(getFeatureProvider(), context.getSourceAnchor().getParent(), 
	    													context.getTargetAnchor().getParent());
	        AddConnectionContext addContext =




import org.eclipse.jpt.jpadiagrameditor.ui.internal.i18n.JPAEditorMessages;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.AbstractRelation;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IBidirectionalRelation;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.UnidirectionalRelation;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.IJPAEditorUtil;

    		feat.delete(delCtx, false);
    	}    	

        if (rel instanceof IBidirectionalRelation) { 			
        	IBidirectionalRelation relation = (IBidirectionalRelation)(rel);
        	ClickRemoveAttributeButtonFeature feat = new ClickRemoveAttributeButtonFeature(getFeatureProvider());
        	
    		JavaPersistentAttribute ownerAttribute = relation.getOwnerAnnotatedAttribute();

    	}    	

        postDelete(context);
        
        /*
        IRemoveContext rc = new RemoveContext(pe);
        IFeatureProvider featureProvider = getFeatureProvider();
        IRemoveFeature removeFeature = featureProvider.getRemoveFeature(rc);
        if (removeFeature != null) {
            removeFeature.remove(rc);
        }
        */
        
        
    }	
    
	public void postDelete(IDeleteContext context) {

		IWorkbenchSite ws = ((IEditorPart)getDiagramEditor()).getSite();
		ICompilationUnit cu = getFeatureProvider().getCompilationUnit(rel.getOwner());		
        ut.organizeImports(cu, ws);        
		if (rel instanceof IBidirectionalRelation) {
			cu = getFeatureProvider().getCompilationUnit(rel.getInverse());
			ut.organizeImports(cu, ws);  
		}




					.getAnchors().iterator().next());
			ctx.setNewObject(rel);
			relF.add(ctx);
//			JpaArtifactFactory.instance().refreshEntityModel(fp, jpt);
		}
		JpaArtifactFactory.instance().rearrangeIsARelations(getFeatureProvider());

	}

	@SuppressWarnings("deprecation")
	private void readdCompartmentsChildren(JavaPersistentType javaPersistentType, ContainerShape entityShape,
			ContainerShape primaryShape, ContainerShape relationShape, ContainerShape basicShape) {
		JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot = JpaArtifactFactory.instance().determineDiagramObjectType(javaPersistentType);
		UpdateAttributeFeature updateFeature = new UpdateAttributeFeature(getFeatureProvider());
		updateFeature.addSeparatorsToShape(primaryShape, dot);
		updateFeature.addSeparatorsToShape(relationShape, dot);
		updateFeature.addSeparatorsToShape(basicShape, dot);

		for (JavaPersistentAttribute attribute : javaPersistentType.getAttributes()) {
			updateFeature.addAttributes(entityShape, attribute);

Added Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/ICreateBiDirRelationFeature.java (+5 lines)
1	package org.eclipse.jpt.jpadiagrameditor.ui.internal.feature;
2
3	public interface ICreateBiDirRelationFeature {
4
5	}

Added Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/ICreateUniDirRelationFeature.java (+5 lines)
1	package org.eclipse.jpt.jpadiagrameditor.ui.internal.feature;
2
3	public interface ICreateUniDirRelationFeature {
4
5	}

Lines 45-51 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/LayoutJPAEntityFeature.java (-1 / +1 lines)
45		45
46	public LayoutJPAEntityFeature(IJPAEditorFeatureProvider fp) {	46	public LayoutJPAEntityFeature(IJPAEditorFeatureProvider fp) {
47	super(fp);	47	super(fp);
48	peUtil = fp.getPeUtil();	48	peUtil = fp.getPeServiceUtil();
49	}	49	}
50		50
51	public boolean canLayout(ILayoutContext context) {	51	public boolean canLayout(ILayoutContext context) {




		final Shape pict = (Shape)getFeatureProvider().getPictogramElementForBusinessObject(jpt);
		JavaPersistentType jpt = (JavaPersistentType)getFeatureProvider().
									getBusinessObjectForPictogramElement(pict);
		final JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot = JpaArtifactFactory.instance().determineDiagramObjectType(jpt);
		final PersistenceUnit pu = JpaArtifactFactory.instance().getPersistenceUnit(jpt);
		final Semaphore s = new Semaphore(0);
		final JPAProjectListener lsnr = new JPAProjectListener(s);

		ted.getCommandStack().execute(new RecordingCommand(ted) {
			@Override
			protected void doExecute() {
				remapEntity(oldName, pict, pu, rename, lsnr, dot, getFeatureProvider());
			}
		});	
	}
	
	public void execute(ICustomContext context, String newName, ICompilationUnit cu, JavaPersistentType jpt) {
		final JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot = JpaArtifactFactory.instance().determineDiagramObjectType(jpt);
		final String oldName = jpt.getName();
		final Shape pict = (Shape)getFeatureProvider().getPictogramElementForBusinessObject(jpt);
		jpt = (JavaPersistentType)getFeatureProvider().

		ted.getCommandStack().execute(new RecordingCommand(ted) {
			@Override
			protected void doExecute() {
				remapEntity(oldName, pict, pu, true, lsnr, dot, getFeatureProvider());
			}
		});
	}

								   final PersistenceUnit pu,
								   final boolean rename,
								   final JPAProjectListener lsnr,
								   final JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot,
								   final IJPAEditorFeatureProvider fp) {
		BusyIndicator.showWhile(Display.getCurrent(), new Runnable() {
			public void run() {

				cont.setY(y);
				cont.setWidth(width);
				cont.setHeight(height);
				RoundedRectangle rect = AddJPAEntityFeature.createEntityRectangle(cont, cs, dot, fp.getDiagramTypeProvider().getDiagram()); 	
				rect.setFilled(true);
				
				IRemoveContext ctx = new RemoveContext(pict); 
				RemoveJPAEntityFeature ft = new RemoveJPAEntityFeature(fp, true);
				
				boolean primaryCollapsed = JPAEditorConstants.TRUE_STRING.equals(Graphiti.getPeService().getPropertyValue(pict, JPAEditorConstants.PRIMARY_COLLAPSED));
				boolean relationCollapsed = JPAEditorConstants.TRUE_STRING.equals(Graphiti.getPeService().getPropertyValue(pict, JPAEditorConstants.RELATION_COLLAPSED));

				addCtx.setY(y);
				addCtx.setWidth(width);
				addCtx.setHeight(height);
				AddJPAEntityFeature ft1 = new AddJPAEntityFeature(fp, true);
				ft.remove(ctx);
				ft1.add(addCtx);
				PictogramElement pe = fp.getPictogramElementForBusinessObject(newJPT);




import org.eclipse.graphiti.features.context.IRemoveContext;
import org.eclipse.graphiti.features.context.impl.RemoveContext;
import org.eclipse.graphiti.features.custom.AbstractCustomFeature;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.graphiti.mm.pictograms.Shape;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;

public abstract class RemoveAllEntitiesFeature extends AbstractCustomFeature {


	}
	
	public void execute(ICustomContext context) {
		TransactionalEditingDomain ted = TransactionUtil.getEditingDomain(getFeatureProvider().getDiagram());
		Iterator<Shape> it = allShapes.iterator();
		while (it.hasNext()) {
			Shape sh = it.next();
			final RemoveJPAEntityFeature ft = new RemoveJPAEntityFeature(this.getFeatureProvider(), false);
			final IRemoveContext ctx = new RemoveContext(sh);
			PictogramElement pe = ctx.getPictogramElement();
			
			TransactionalEditingDomain ted = TransactionUtil.getEditingDomain(pe);
			ted.getCommandStack().execute(new RecordingCommand(ted) {
				@Override
				protected void doExecute() {

		}
	}

	public IJPAEditorFeatureProvider getFeatureProvider() {
		return (IJPAEditorFeatureProvider) super.getFeatureProvider();
	}

}

Lines 30-35 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/RemoveAndSaveEntityFeature.java (+6 lines)
30	import org.eclipse.jpt.jpa.core.context.PersistentType;	30	import org.eclipse.jpt.jpa.core.context.PersistentType;
31	import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;	31	import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
32	import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;	32	import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;
		33	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
33		34
34		35
35		36
Lines 67-70 Link Here
67	return (IJPAEditorFeatureProvider)super.getFeatureProvider();	68	return (IJPAEditorFeatureProvider)super.getFeatureProvider();
68	}	69	}
69		70
		71	public void postRemove(IRemoveContext context) {
		72	JpaArtifactFactory.instance().rearrangeIsARelations(getFeatureProvider());
		73	}
		74
		75
70	}	76	}

Lines 154-161 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/RemoveAttributeFeature.java (-1 / +1 lines)
154	cntx.setNewObject(rel);	154	cntx.setNewObject(rel);
155	AddRelationFeature ft = new AddRelationFeature(getFeatureProvider());	155	AddRelationFeature ft = new AddRelationFeature(getFeatureProvider());
156	ft.add(cntx);	156	ft.add(cntx);
157	// JpaArtifactFactory.instance().refreshEntityModel(getFeatureProvider(), jpt);
158	}	157	}
		158	JpaArtifactFactory.instance().rearrangeIsARelations(getFeatureProvider());
159	}	159	}
160		160
161	}	161	}





public class RemoveJPAEntityFeature extends DefaultRemoveFeature {
	
	private boolean shouldRearrangeIsARelations = true;
	
    public RemoveJPAEntityFeature(IFeatureProvider fp, boolean shouldRearrangeIsARelations) {
    	super(fp);
    	this.shouldRearrangeIsARelations = shouldRearrangeIsARelations;
    }
    
    public void preRemove(IRemoveContext context) {
    	PictogramElement pe = context.getPictogramElement();
    			
//		RestoreEntityFeature ft = new RestoreEntityFeature(getFeatureProvider());
//		ICustomContext customContext = new CustomContext(new PictogramElement[] { pe });
//		ft.execute(customContext);
    	
    	final Object bo = getFeatureProvider().getBusinessObjectForPictogramElement(pe);
    	Set<Shape> shapesForDeletion = new HashSet<Shape>();
    	if (bo instanceof JavaPersistentType) {

				IRemoveContext ctx = new RemoveContext(it.next());
				f.remove(ctx);    			
    		}
    		String name = ((PersistentType)bo).getName();
			getFeatureProvider().remove(name, true);
    		//Job job = new Job("Remove JPA entity") {				//$NON-NLS-1$
			//	protected IStatus run(IProgressMonitor monitor) {
		    		String name = ((PersistentType)bo).getName();
					getFeatureProvider().remove(name, true);
					//return new Status(IStatus.OK, 
					//	  JPADiagramEditorPlugin.PLUGIN_ID, 
					//	  name + " is removed"); 	//$NON-NLS-1$
									  
			//	}
    		//};
    		//job.schedule();
    		//---------------------------------------------------------------------
    	} 			
    }
    

		super.execute(context);
	}
	
    public void postRemove(IRemoveContext context) {
    	if (shouldRearrangeIsARelations)
    		JpaArtifactFactory.instance().rearrangeIsARelations(getFeatureProvider());
    }
	
}




import org.eclipse.graphiti.mm.pictograms.ContainerShape;
import org.eclipse.graphiti.mm.pictograms.Shape;
import org.eclipse.graphiti.services.Graphiti;
import org.eclipse.graphiti.util.IColorConstant;
import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;

		return rect;
	}

	public void addSeparatorsToShape(ContainerShape compartmentShape,
			JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot) {
		addSeparatorToCollection(compartmentShape, 0, dot);
		addSeparatorToCollection(compartmentShape, JPAEditorConstants.COMPARTMENT_MIN_HEIGHT, dot);
	}

	private Shape addSeparatorToCollection(ContainerShape containerShape, int y, 
										   JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot) {
		final int width = containerShape.getGraphicsAlgorithm().getWidth();
		Shape shape = Graphiti.getPeService().createShape(containerShape, false);
		Rectangle rectangle = Graphiti.getGaService().createRectangle(shape);
		IColorConstant foreground = JpaArtifactFactory.instance().getForeground(dot);
		IColorConstant background = JpaArtifactFactory.instance().getBackground(dot);
		rectangle.setForeground(manageColor(background));
		rectangle.setBackground(manageColor(foreground));
		rectangle.setLineVisible(false);
		Graphiti.getGaService().setSize(rectangle, width, JPAEditorConstants.SEPARATOR_HEIGHT);
		Graphiti.getGaService().setLocationAndSize(rectangle, 0, y, width, JPAEditorConstants.SEPARATOR_HEIGHT);




        if (firstElement instanceof JpaNode) {
        	jpaProject = ((JpaNode)firstElement).getJpaProject();
        } else if (firstElement instanceof IProject) {
        	int cnt = 0;
    		while ((jpaProject == null) && (cnt < 25)) { 
    			jpaProject = JpaArtifactFactory.instance().getJpaProject((IProject)firstElement);
    			if (jpaProject == null) {
    				try {
    					Thread.sleep(200);
    				} catch (InterruptedException e) {
    					JPADiagramEditorPlugin.logError("Thread sleep interrupted", e);  //$NON-NLS-1$		 
    				}
    			}
    			cnt++;
    		}
        }
        return JpaArtifactFactory.instance().getPersistenceUnit(jpaProject);
	}

Lines 294-299 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/modelintegration/util/ModelIntegrationUtil.java (+2 lines)
294		294
295	public static JPAEditorDiagramTypeProvider getProviderByDiagram(String diagramName) {	295	public static JPAEditorDiagramTypeProvider getProviderByDiagram(String diagramName) {
296	IWorkbenchWindow workbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();	296	IWorkbenchWindow workbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
		297	if (workbenchWindow == null)
		298	return null;
297	IWorkbenchPage workbenchPage = workbenchWindow.getActivePage();	299	IWorkbenchPage workbenchPage = workbenchWindow.getActivePage();
298	IEditorReference[] editorRefs = workbenchPage.getEditorReferences();	300	IEditorReference[] editorRefs = workbenchPage.getEditorReferences();
299	for (IEditorReference editorRef : editorRefs) {	301	for (IEditorReference editorRef : editorRefs) {

Lines 15-20 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/IJPAEditorFeatureProvider.java (-1 / +22 lines)
15	*******************************************************************************/	15	*******************************************************************************/
16	package org.eclipse.jpt.jpadiagrameditor.ui.internal.provider;	16	package org.eclipse.jpt.jpadiagrameditor.ui.internal.provider;
17		17
		18	import java.util.Collection;
		19	import java.util.HashSet;
18	import java.util.Properties;	20	import java.util.Properties;
19		21
20	import org.eclipse.core.resources.IProject;	22	import org.eclipse.core.resources.IProject;
Lines 23-29 Link Here
23	import org.eclipse.graphiti.features.IFeatureProvider;	25	import org.eclipse.graphiti.features.IFeatureProvider;
24	import org.eclipse.graphiti.features.context.IDeleteContext;	26	import org.eclipse.graphiti.features.context.IDeleteContext;
25	import org.eclipse.graphiti.features.custom.ICustomFeature;	27	import org.eclipse.graphiti.features.custom.ICustomFeature;
		28	import org.eclipse.graphiti.mm.pictograms.Diagram;
26	import org.eclipse.graphiti.mm.pictograms.Shape;	29	import org.eclipse.graphiti.mm.pictograms.Shape;
		30	import org.eclipse.graphiti.services.IPeService;
27	import org.eclipse.jdt.core.ICompilationUnit;	31	import org.eclipse.jdt.core.ICompilationUnit;
28	import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;	32	import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
29	import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;	33	import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
Lines 32-37 Link Here
32	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation;	36	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation;
33	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation.RelDir;	37	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation.RelDir;
34	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation.RelType;	38	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation.RelType;
		39	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IsARelation;
35	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.IGraphicsUpdater;	40	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.IGraphicsUpdater;
36	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.IJPAEditorUtil;	41	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.IJPAEditorUtil;
37	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.IPeServiceUtil;	42	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.IPeServiceUtil;
Lines 39-44 Link Here
39		44
40	public interface IJPAEditorFeatureProvider extends IFeatureProvider{	45	public interface IJPAEditorFeatureProvider extends IFeatureProvider{
41		46
		47	public Diagram getDiagram();
		48
		49	public HashSet<IsARelation> getAllRedundantIsARelations();
		50
		51	public HashSet<IsARelation> getAllExistingIsARelations();
		52
42	public ICompilationUnit getCompilationUnit(JavaPersistentType jpt);	53	public ICompilationUnit getCompilationUnit(JavaPersistentType jpt);
43		54
44	public boolean hasObjectWithName(String name);	55	public boolean hasObjectWithName(String name);
Lines 80-87 Link Here
80	public void replaceAttribute(JavaPersistentAttribute oldAt, JavaPersistentAttribute newAt);	91	public void replaceAttribute(JavaPersistentAttribute oldAt, JavaPersistentAttribute newAt);
81		92
82	public void renewAttributeJoiningStrategyPropertyListener(JavaPersistentAttribute jpa);	93	public void renewAttributeJoiningStrategyPropertyListener(JavaPersistentAttribute jpa);
		94
		95	public IPeService getPeService();
83		96
84	public IPeServiceUtil getPeUtil();	97	public IPeServiceUtil getPeServiceUtil();
85		98
86	public IJPAEditorUtil getJPAEditorUtil();	99	public IJPAEditorUtil getJPAEditorUtil();
87		100
Lines 99-102 Link Here
99		112
100	public Properties loadProperties(IProject project);	113	public Properties loadProperties(IProject project);
101		114
		115	public Collection<JavaPersistentType> getPersistentTypes();
		116
		117	public JavaPersistentType getFirstSuperclassBelongingToTheDiagram(JavaPersistentType subclass);
		118
		119	public void removeAllRedundantIsARelations();
		120
		121	public boolean existRedundantIsARelations();
		122
102	}	123	}

Lines 31-39 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/IJPAEditorImageCreator.java (-1 / +5 lines)
31		31
32	public Polyline createConnectionLine(Diagram d, Connection connection);	32	public Polyline createConnectionLine(Diagram d, Connection connection);
33		33
		34	public Polyline createIsAConnectionLine(Diagram d, Connection connection);
		35
34	//public ConnectionDecorator createTextConnectionDecorator(Connection connection, String text, double location);	36	//public ConnectionDecorator createTextConnectionDecorator(Connection connection, String text, double location);
35		37
36	public ConnectionDecorator createArrowConnectionDecorator(Connection connection, double location);	38	public ConnectionDecorator createArrowConnectionDecorator(Connection connection, double location, boolean isA);
37		39
38	public ConnectionDecorator createManyEndWithArrowDecorator(Connection connection, double location);	40	public ConnectionDecorator createManyEndWithArrowDecorator(Connection connection, double location);
39		41
Lines 45-49 Link Here
45		47
46	public ConnectionDecorator createCardinalityConnectionDecorator(Diagram d, Connection c, String text, double location);	48	public ConnectionDecorator createCardinalityConnectionDecorator(Diagram d, Connection c, String text, double location);
47		49
		50	public ConnectionDecorator createIsATextConnectionDecorator(Diagram d, Connection c);
		51
48		52
49	}	53	}

Lines 266-275 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/JPAEditorDiagramTypeProvider.java (-1 / +2 lines)
266	ctx.setHeight(sp.getHeight());	266	ctx.setHeight(sp.getHeight());
267	ctx.setX(sp.getX());	267	ctx.setX(sp.getX());
268	ctx.setY(sp.getY());	268	ctx.setY(sp.getY());
269	AddJPAEntityFeature ft = new AddJPAEntityFeature(getFeatureProvider());	269	AddJPAEntityFeature ft = new AddJPAEntityFeature(getFeatureProvider(), false);
270	ft.add(ctx);	270	ft.add(ctx);
271	}	271	}
272	}	272	}
		273	JpaArtifactFactory.instance().rearrangeIsARelations(getFeatureProvider());
273	}	274	}
274	});	275	});
275	getDiagramEditor().saveWithoutEntities(new NullProgressMonitor());	276	getDiagramEditor().saveWithoutEntities(new NullProgressMonitor());




import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Properties;

import org.eclipse.core.resources.IProject;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.transaction.RecordingCommand;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.emf.transaction.util.TransactionUtil;

import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.graphiti.mm.pictograms.Shape;
import org.eclipse.graphiti.services.Graphiti;
import org.eclipse.graphiti.services.IPeService;
import org.eclipse.graphiti.ui.features.DefaultFeatureProvider;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.internal.core.CompilationUnit;
import org.eclipse.jdt.internal.core.SourceType;
import org.eclipse.jpt.jpa.core.JpaNode;
import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
import org.eclipse.jpt.jpa.core.context.PersistentType;
import org.eclipse.jpt.jpa.core.context.java.JavaEntity;
import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;

import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.CollapseCompartmentShapeFeature;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.CollapseEntityFeature;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.CreateJPAEntityFeature;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.CreateJPAEntityFromMappedSuperclassFeature;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.CreateManyToManyBiDirRelationFeature;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.CreateManyToManyUniDirRelationFeature;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.CreateManyToOneBiDirRelationFeature;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.CreateManyToOneUniDirRelationFeature;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.CreateMappedSuperclassFeature;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.CreateOneToManyUniDirRelationFeature;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.CreateOneToOneBiDirRelationFeature;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.CreateOneToOneUniDirRelationFeature;

import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation.RelDir;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation.RelType;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IsARelation;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.GraphicsUpdaterImpl;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.IGraphicsUpdater;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.IJPAEditorUtil;

	
	private ClickAddAttributeButtonFeature clickAddAttBtnFeat = null;
	private ClickRemoveAttributeButtonFeature clickRemoveAttBtnFeat = null;
	private IPeServiceUtil peServiceUtil = new PeServiceUtilImpl();
	private IPeService peService = Graphiti.getPeService();
	private IJPAEditorUtil jpaEditorUtil = new JPAEditorUtilImpl();
	private IModelIntegrationUtil moinIntegrationUtil = new ModelIntegrationUtilImpl(); 
	private IGraphicsUpdater graphicsUpdater = new GraphicsUpdaterImpl(); 

    		((JPASolver)getIndependenceSolver()).stopThread();
    }
    
	public Diagram getDiagram() {
		return getDiagramTypeProvider().getDiagram();
	}

	public HashSet<IsARelation> getAllExistingIsARelations() {
		EList<Connection> allCons = getDiagram().getConnections();
		HashSet<IsARelation> res = new HashSet<IsARelation>();
		HashSet<Connection> tbd = new HashSet<Connection>();
		for (Connection conn : allCons) {
			if (IsARelation.isIsAConnection(conn)) 
				try { 
					res.add(new IsARelation(this, conn));
				} catch (NullPointerException e) {
					tbd.add(conn);
				}
		}
		Iterator<Connection> it = tbd.iterator();
		while (it.hasNext()) {
			Graphiti.getPeService().deletePictogramElement(it.next());
		}
		return res;
	}
	
	public HashSet<IsARelation> getAllRedundantIsARelations() {
		EList<Connection> allCons = getDiagram().getConnections();
		HashSet<IsARelation> res = new HashSet<IsARelation>();
		for (Connection conn : allCons) {
			if (IsARelation.isIsAConnection(conn)) 
				res.add(new IsARelation(this, conn));
		}
		return res;
	}
	
	public void removeAllRedundantIsARelations() {
		EList<Connection> allCons = getDiagram().getConnections();
		Collection<Connection> redundantConnections = new LinkedList<Connection>();
		for (Connection conn : allCons) {
			if (IsARelation.isIsAConnection(conn)) {
				IsARelation rel = null;
				try {
					rel = new IsARelation(this, conn);	
				} catch (NullPointerException e) {
					redundantConnections.add(conn);
					continue;
				}
				if (!rel.getSuperclass().getName().equals(getFirstSuperclassBelongingToTheDiagram(rel.getSubclass()).getName())) {
					redundantConnections.add(conn);
				}
			}
		}
		Iterator<Connection> it = redundantConnections.iterator();
		while (it.hasNext()) {
			Connection conn = it.next();
			peService.deletePictogramElement(conn);
		}	
	}
	
	public boolean existRedundantIsARelations() {
		EList<Connection> allCons = getDiagram().getConnections();
		for (Connection conn : allCons) {
			if (IsARelation.isIsAConnection(conn)) {
				IsARelation rel = null;
				try {
					rel = new IsARelation(this, conn);	
				} catch (NullPointerException e) {
					return true;
				}
				if (!rel.getSuperclass().equals(getFirstSuperclassBelongingToTheDiagram(rel.getSubclass()))) {
					return true;
				}
			}
		}
		return false;
	}
		
	public JavaPersistentType getFirstSuperclassBelongingToTheDiagram(JavaPersistentType subclass) {
		Iterable<PersistentType> h = subclass.getInheritanceHierarchy();
		Iterator<PersistentType> iter = h.iterator();
		if (!iter.hasNext())
			return null;
		HashSet<PersistentType> cycleChecker = new HashSet<PersistentType>();
		cycleChecker.add(iter.next());
		while (iter.hasNext()) {
			PersistentType superclass = iter.next();
			if (hasObjectWithName(getKeyForBusinessObject(superclass))) {
				return (JavaPersistentType) superclass;
			}
			if (!cycleChecker.add(superclass))
				return null;
		}
		return null;
	}
	
    
	public void addJPTForUpdate(String jptName) {
		((JPASolver)getIndependenceSolver()).addJPTForUpdate(jptName);
	}

    public IAddFeature getAddFeature(IAddContext context) {
    	Object newObj = context.getNewObject(); 
        if (newObj instanceof JavaPersistentType) {
            return new AddJPAEntityFeature(this, true);
        } else if (newObj instanceof AbstractRelation) {
        	 return new AddRelationFeature(this);
        } else if (newObj instanceof PersistentAttribute) { 

        } else if (newObj instanceof CompilationUnit) {
        	CompilationUnit cu = (CompilationUnit)newObj;
        	JavaPersistentType jpt = JPAEditorUtil.getJPType(cu);
        	if (jpt != null) return new AddJPAEntityFeature(this, true);
        } else if ((newObj instanceof JpaNode)) {
        	return new AddAllEntitiesFeature(this);
        } else if (newObj instanceof SourceType) {
        	return new AddJPAEntityFeature(this, true);
        }
        return super.getAddFeature(context);
    }

    
    @Override
    public ICreateFeature[] getCreateFeatures() {
    	return new ICreateFeature[] {new CreateJPAEntityFeature(this), 
    								 new CreateMappedSuperclassFeature(this)};
    }
    
    @Override

        if (bo == null)
        	super.getRemoveFeature(context);
    	if (bo instanceof JavaPersistentType) {
    		return new RemoveJPAEntityFeature(this, true);	
    	} else if (bo instanceof AbstractRelation) { 
    		return new RemoveRelationFeature(this);
    	}

    	return ((JPASolver)getIndependenceSolver()).remove(key);
    }    
    
    public Collection<JavaPersistentType> getPersistentTypes() {
    	return ((JPASolver)getIndependenceSolver()).getPersistentTypes();
    }
    
    protected void removeAllConnections(Shape shape) {
		for (Iterator<Anchor> iter = shape.getAnchors().iterator(); iter.hasNext();) {

		((JPASolver)getIndependenceSolver()).dispose();
		setIndependenceSolver(null);
	}
	
	public IPeService getPeService() {
		return peService;
	}

	public IPeServiceUtil getPeServiceUtil() {
		return peServiceUtil;
		return peUtil;
	}
	
	public IJPAEditorUtil getJPAEditorUtil() {




import org.eclipse.graphiti.mm.algorithms.Image;
import org.eclipse.graphiti.mm.algorithms.Polyline;
import org.eclipse.graphiti.mm.algorithms.Text;
import org.eclipse.graphiti.mm.algorithms.styles.LineStyle;
import org.eclipse.graphiti.mm.pictograms.Connection;
import org.eclipse.graphiti.mm.pictograms.ConnectionDecorator;
import org.eclipse.graphiti.mm.pictograms.Diagram;

		return polyline;
	}

	public Polyline createIsAConnectionLine(Diagram d, Connection connection) {
		Polyline polyline = Graphiti.getGaService().createPolyline(connection);
		polyline.setForeground(Graphiti.getGaService().manageColor(d, JPAEditorConstants.IS_A_CONNECTION_LINE_COLOR));
		polyline.setLineWidth(JPAEditorConstants.IS_A_CONNECTION_LINE_WIDTH);
		polyline.setLineStyle(LineStyle.DASH);
		return polyline;
		Graphiti.getGaService().manageColor(connection.getParent(), IColorConstant.BLACK);
		Graphiti.getGaService().setLocation(txt, 5, -20);
		return textDecorator;
	}
		
	
	public ConnectionDecorator createCardinalityConnectionDecorator(Diagram d, Connection c, String text, double location) {
		ConnectionDecorator textDecorator = Graphiti.getPeService().createConnectionDecorator(c, true, location, true);
		Text txt = Graphiti.getGaService().createDefaultText(d, textDecorator);

		return textDecorator;
	}

	public ConnectionDecorator createArrowConnectionDecorator(Connection connection, 
															  double location,
															  boolean isA) {
		ConnectionDecorator cd = Graphiti.getPeService().createConnectionDecorator(connection, false, location, true);
		Polyline arrow = Graphiti.getGaService().createPolyline(cd, new int[] { 11, 3, 0, 0, 11, -3, 11, 3 });
		arrow.setForeground(Graphiti.getGaService().manageColor(connection.getParent(), isA ? 
																						JPAEditorConstants.IS_A_CONNECTION_LINE_COLOR : 
																						JPAEditorConstants.CONNECTION_LINE_COLOR));
		arrow.setLineWidth(JPAEditorConstants.CONNECTION_LINE_WIDTH);
		return cd;
	}

		return iconDecorator;
	}

	public ConnectionDecorator createIsATextConnectionDecorator(Diagram d, Connection c) {
		ConnectionDecorator textDecorator = Graphiti.getPeService().createConnectionDecorator(c, true, 0.5, true);
		Text txt = Graphiti.getGaService().createDefaultText(d, textDecorator);
		txt.setLineWidth(JPAEditorConstants.CONNECTION_LINE_WIDTH);
		txt.setValue(JPAEditorConstants.IS_A);
		Graphiti.getGaService().manageColor(c.getParent(), IColorConstant.BLACK);
		//Point pt = JPAEditorUtil.recalcTextDecoratorPosition((FreeFormConnection)c, textDecorator);
		Graphiti.getGaService().setLocation(txt, 5, 5, false);
		return textDecorator;		
	}

}




import org.eclipse.graphiti.ui.platform.AbstractImageProvider;

public class JPAEditorImageProvider extends AbstractImageProvider {
	
	private final static String PREFIX = "org.eclipse.jpt.jpadiagrameditor.ui."; 						//$NON-NLS-1$
    public final static String ID	= "org.eclipse.jpt.jpadiagrameditor.ui.JPAEditorImageProvider";		//$NON-NLS-1$
    
    public static final String JPA_ENTITY 				= PREFIX + "entity"; 							//$NON-NLS-1$
    public static final String MAPPED_SUPERCLASS 		= PREFIX + "mapped_superclass"; 				//$NON-NLS-1$
    public static final String ADD_JPA_ENTITY 			= PREFIX + "add_entity"; 						//$NON-NLS-1$    
    public static final String ADD_INHERITED_ENTITY 	= PREFIX + "add_inherited_entity";		        //$NON-NLS-1$
    public static final String ADD_MAPPED_SUPERCLASS	= PREFIX + "add_mapped_superclass";	        	//$NON-NLS-1$    
    public static final String PRIMARY_KEY 				= PREFIX + "pk"; 								//$NON-NLS-1$
    public static final String ICON_BASIC 				= PREFIX + "field"; 							//$NON-NLS-1$
    public static final String ADD_ATTRIBUTE 			= PREFIX + "add_attribute"; 					//$NON-NLS-1$
    public static final String REMOVE_ATTRIBUTE 		= PREFIX + "remove_attribute"; 					//$NON-NLS-1$
    public static final String ICON_ONE_TO_ONE 			= PREFIX + "one_to_one_relation"; 				//$NON-NLS-1$
    public static final String ICON_ONE_TO_MANY 		= PREFIX + "one_to_many_relation"; 				//$NON-NLS-1$
    public static final String ICON_MANY_TO_ONE 		= PREFIX + "many_to_one_relation"; 				//$NON-NLS-1$
    public static final String ICON_MANY_TO_MANY 		= PREFIX + "many_to_many_relation"; 			//$NON-NLS-1$
    public static final String ICON_EMBEDDED_ID 		= PREFIX + "embedded_id"; 						//$NON-NLS-1$
    public static final String ICON_VERSION 			= PREFIX + "version"; 							//$NON-NLS-1$ 
    public static final String ICON_TRANSIENT 			= PREFIX + "transient"; 						//$NON-NLS-1$  
    public static final String ICON_EMBEDDED 			= PREFIX + "embedded"; 							//$NON-NLS-1$ 
    public static final String ICON_UNMAPPED 			= PREFIX + "unmapped"; 							//$NON-NLS-1$  


    public static final String ICON_ONE_TO_ONE_1_DIR 	= PREFIX + "one_to_one_1_dir_relation"; 		//$NON-NLS-1$
    public static final String ICON_ONE_TO_MANY_1_DIR 	= PREFIX + "one_to_many_1_dir_relation"; 		//$NON-NLS-1$
    public static final String ICON_MANY_TO_ONE_1_DIR 	= PREFIX + "many_to_one_1_dir_relation"; 		//$NON-NLS-1$    
    public static final String ICON_MANY_TO_MANY_1_DIR 	= PREFIX + "many_to_many_1_dir_relation"; 		//$NON-NLS-1$

    public static final String ICON_ONE_TO_ONE_2_DIR 	= PREFIX + "one_to_one_2_dir_relation"; 		//$NON-NLS-1$
    public static final String ICON_MANY_TO_ONE_2_DIR 	= PREFIX + "many_to_one_2_dir_relation"; 		//$NON-NLS-1$    
    public static final String ICON_MANY_TO_MANY_2_DIR 	= PREFIX + "many_to_many_2_dir_relation"; 		//$NON-NLS-1$
    
    
    public static final String ICON_SAVE 				= PREFIX + "save"; 								//$NON-NLS-1$
    public static final String ICON_RESTORE 			= PREFIX + "restore"; 							//$NON-NLS-1$
    public static final String ICON_SAVE_AND_REMOVE 	= PREFIX + "save_and_remove"; 					//$NON-NLS-1$

	private static final String ROOT_FOLDER_FOR_IMG 	= "icons/"; 									//$NON-NLS-1$

    public JPAEditorImageProvider() {
        super();

    @Override
    protected void addAvailableImages() {        
        addImageFilePath(ICON_BASIC, ROOT_FOLDER_FOR_IMG + "ent/basic.gif");							//$NON-NLS-1$
        addImageFilePath(JPA_ENTITY, ROOT_FOLDER_FOR_IMG + "ent/entity.gif");							//$NON-NLS-1$
        addImageFilePath(MAPPED_SUPERCLASS, ROOT_FOLDER_FOR_IMG + "ent/mapped-superclass.gif");			//$NON-NLS-1$
        addImageFilePath(ADD_JPA_ENTITY, ROOT_FOLDER_FOR_IMG + "ent/add_entity.gif");					//$NON-NLS-1$        
        addImageFilePath(ADD_INHERITED_ENTITY, ROOT_FOLDER_FOR_IMG + "ent/add_entity.gif"); 			//$NON-NLS-1$
        addImageFilePath(ADD_MAPPED_SUPERCLASS, ROOT_FOLDER_FOR_IMG + "ent/add_mapped-superclass.gif"); //$NON-NLS-1$
        addImageFilePath(PRIMARY_KEY, ROOT_FOLDER_FOR_IMG + "ent/id.gif");								//$NON-NLS-1$
        addImageFilePath(ADD_ATTRIBUTE, ROOT_FOLDER_FOR_IMG + "ent/add_attribute.gif");					//$NON-NLS-1$
        addImageFilePath(REMOVE_ATTRIBUTE, ROOT_FOLDER_FOR_IMG + "ent/remove_attribute.gif");			//$NON-NLS-1$
        addImageFilePath(ICON_ONE_TO_ONE, ROOT_FOLDER_FOR_IMG + "ent/one-to-one.gif");					//$NON-NLS-1$
        addImageFilePath(ICON_ONE_TO_MANY, ROOT_FOLDER_FOR_IMG + "ent/one-to-many.gif");				//$NON-NLS-1$
        addImageFilePath(ICON_MANY_TO_ONE, ROOT_FOLDER_FOR_IMG + "ent/many-to-one.gif");				//$NON-NLS-1$
        addImageFilePath(ICON_MANY_TO_MANY, ROOT_FOLDER_FOR_IMG + "ent/many-to-many.gif");				//$NON-NLS-1$
        addImageFilePath(ICON_EMBEDDED_ID, ROOT_FOLDER_FOR_IMG + "ent/embedded-id.gif"); 				//$NON-NLS-1$
        addImageFilePath(ICON_VERSION, ROOT_FOLDER_FOR_IMG + "ent/version.gif"); 						//$NON-NLS-1$
        addImageFilePath(ICON_TRANSIENT, ROOT_FOLDER_FOR_IMG + "ent/transient.gif"); 					//$NON-NLS-1$
        addImageFilePath(ICON_EMBEDDED, ROOT_FOLDER_FOR_IMG + "ent/embedded.gif"); 						//$NON-NLS-1$
        addImageFilePath(ICON_UNMAPPED, ROOT_FOLDER_FOR_IMG + "ent/null-attribute-mapping.gif"); 		//$NON-NLS-1$

        addImageFilePath(ICON_ONE_TO_ONE_1_DIR, ROOT_FOLDER_FOR_IMG + "ent/one-to-one-1-dir.gif");		//$NON-NLS-1$
        addImageFilePath(ICON_ONE_TO_MANY_1_DIR, ROOT_FOLDER_FOR_IMG + "ent/one-to-many-1-dir.gif");	//$NON-NLS-1$
        addImageFilePath(ICON_MANY_TO_ONE_1_DIR, ROOT_FOLDER_FOR_IMG + "ent/many-to-one-1-dir.gif");	//$NON-NLS-1$        
        addImageFilePath(ICON_MANY_TO_MANY_1_DIR, ROOT_FOLDER_FOR_IMG + "ent/many-to-many-1-dir.gif");	//$NON-NLS-1$
        
        addImageFilePath(ICON_ONE_TO_ONE_2_DIR, ROOT_FOLDER_FOR_IMG + "ent/one-to-one-2-dir.gif");		//$NON-NLS-1$
        addImageFilePath(ICON_MANY_TO_ONE_2_DIR, ROOT_FOLDER_FOR_IMG + "ent/many-to-one-2-dir.gif");	//$NON-NLS-1$        
        addImageFilePath(ICON_MANY_TO_MANY_2_DIR, ROOT_FOLDER_FOR_IMG + "ent/many-to-many-2-dir.gif");	//$NON-NLS-1$        
                
        addImageFilePath(ICON_SAVE, ROOT_FOLDER_FOR_IMG + "save.gif");									//$NON-NLS-1$
        addImageFilePath(ICON_RESTORE, ROOT_FOLDER_FOR_IMG + "restore.gif");							//$NON-NLS-1$
        addImageFilePath(ICON_SAVE_AND_REMOVE, ROOT_FOLDER_FOR_IMG + "save_and_remove.gif");			//$NON-NLS-1$
    }
    
}




import org.eclipse.graphiti.mm.pictograms.Shape;
import org.eclipse.graphiti.palette.IPaletteCompartmentEntry;
import org.eclipse.graphiti.palette.IToolEntry;
import org.eclipse.graphiti.palette.impl.ConnectionCreationToolEntry;
import org.eclipse.graphiti.palette.impl.PaletteCompartmentEntry;
import org.eclipse.graphiti.platform.IPlatformImageConstants;
import org.eclipse.graphiti.services.Graphiti;

import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.CollapseAllEntitiesFeature;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.CollapseCompartmentShapeFeature;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.CollapseEntityFeature;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.CreateInheritedEntityFeature;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.DeleteJPAEntityFeature;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.DiscardAndRemoveAllEntitiesFeature;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.ExpandAllEntitiesFeature;

import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.GraphicsUpdater;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.IEclipseFacade;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorConstants;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorUtil;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorConstants.ShapeType;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorUtil;
import org.eclipse.ui.PartInitException;

@SuppressWarnings("restriction")

        IPaletteCompartmentEntry en = ret.get(0);
        ret.set(0, ret.get(1));
        ret.set(1, en);
        
    	PaletteCompartmentEntry ent = new PaletteCompartmentEntry(JPAEditorMessages.JPAEditorToolBehaviorProvider_InheritanceCompartmentTitle, superCompartments[1].getIconId());     
    	CreateInheritedEntityFeature ft = new CreateInheritedEntityFeature(this.getFeatureProvider());
    	ConnectionCreationToolEntry isARelToolEntry = new ConnectionCreationToolEntry(ft.getCreateName(),
				ft.getCreateDescription(), ft.getCreateImageId(), ft.getCreateLargeImageId());
    	isARelToolEntry.addCreateConnectionFeature(ft);
    	
		ent.addToolEntry(isARelToolEntry);

    	
    	ret.add(1, ent);

        return ret.toArray(new IPaletteCompartmentEntry[ret.size()]);
    }
   




/*******************************************************************************
 * <copyright>
 *
 * Copyright (c) 2005, 2010 SAP AG.
 * 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:
 *    Stefan Dimov - initial API, implementation and documentation
 *
 * </copyright>
 *
 *******************************************************************************/
package org.eclipse.jpt.jpadiagrameditor.ui.internal.relations;

import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;

public interface BidirectionalRelation extends IRelation {
	
	public abstract JavaPersistentAttribute getOwnerAnnotatedAttribute();

	public abstract JavaPersistentAttribute getInverseAnnotatedAttribute();

	public abstract void setOwnerAnnotatedAttribute(JavaPersistentAttribute ownerAnnotatedAttribute);

	public abstract void setInverseAnnotatedAttribute(JavaPersistentAttribute inverseAnnotatedAttribute); 

}




/*******************************************************************************
 * <copyright>
 *
 * Copyright (c) 2005, 2010 SAP AG.
 * 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:
 *    Stefan Dimov - initial API, implementation and documentation
 *
 * </copyright>
 *
 *******************************************************************************/
package org.eclipse.jpt.jpadiagrameditor.ui.internal.relations;

import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;

public interface IBidirectionalRelation extends IRelation {
	
	public abstract JavaPersistentAttribute getOwnerAnnotatedAttribute();

	public abstract JavaPersistentAttribute getInverseAnnotatedAttribute();

	public abstract void setOwnerAnnotatedAttribute(JavaPersistentAttribute ownerAnnotatedAttribute);

	public abstract void setInverseAnnotatedAttribute(JavaPersistentAttribute inverseAnnotatedAttribute); 

}




/*******************************************************************************
 * <copyright>
 *
 * Copyright (c) 2005, 2010 SAP AG.
 * 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:
 *    Stefan Dimov - initial API, implementation and documentation
 *
 * </copyright>
 *
 *******************************************************************************/
package org.eclipse.jpt.jpadiagrameditor.ui.internal.relations;

import org.eclipse.graphiti.mm.pictograms.Anchor;
import org.eclipse.graphiti.mm.pictograms.Connection;
import org.eclipse.graphiti.mm.pictograms.ContainerShape;
import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorConstants;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorUtil;

public class IsARelation {

	protected final static String SEPARATOR = ";isA;";							//$NON-NLS-1$
	public final static String IS_A_CONNECTION_PROP_KEY = "is_is_a_connection";	//$NON-NLS-1$
	
	
	protected JavaPersistentType subclass;
	protected JavaPersistentType superclass;
	
	public IsARelation(JavaPersistentType subclass, 
					   JavaPersistentType superclass) {
		this.subclass = subclass;
		this.superclass = superclass;
	}
	
	public IsARelation(IJPAEditorFeatureProvider fp, Connection conn) {
		Anchor start = conn.getStart();
		Anchor end = conn.getEnd();
		Object startObj = fp.getBusinessObjectForPictogramElement((ContainerShape)start.eContainer());
		Object endObj = fp.getBusinessObjectForPictogramElement((ContainerShape)end.eContainer());
		if ((startObj == null) || (endObj == null))
			throw new NullPointerException("Some of the connection ends is null");	//$NON-NLS-1$
		if (!(startObj instanceof JavaPersistentType) || !(endObj instanceof JavaPersistentType))
			throw new IllegalArgumentException();
		this.subclass = (JavaPersistentType)startObj;
		this.superclass = (JavaPersistentType)endObj;
	}
	
	
	public JavaPersistentType getSubclass() {
		return subclass; 
	}
	
	public JavaPersistentType getSuperclass() {
		return superclass; 
	}
	
	public static boolean isIsAConnection(Connection conn) {
		String val = JPAEditorUtil.getPeUtil().getPropertyValue(conn, IS_A_CONNECTION_PROP_KEY);
		return (Boolean.TRUE.toString().equals(val));
	}


	public String getId() {
		return generateId(subclass, superclass);
	}
	
	public static String generateId(IJPAEditorFeatureProvider fp, Connection conn) {
		Anchor start = conn.getStart();
		Anchor end = conn.getEnd();
		Object startObj = fp.getBusinessObjectForPictogramElement((ContainerShape)start.eContainer());
		Object endObj = fp.getBusinessObjectForPictogramElement((ContainerShape)end.eContainer());
		if ((startObj == null) || (endObj == null))
			return null;
		if (!(startObj instanceof JavaPersistentType) || !(endObj instanceof JavaPersistentType))
			return null;
		JavaPersistentType startJpt = (JavaPersistentType)startObj;
		JavaPersistentType endJpt = (JavaPersistentType)endObj;
		return generateId(startJpt, endJpt);
	}
	
	private static String generateId(JavaPersistentType startJpt, JavaPersistentType endJpt) {
		return JPAEditorConstants.IS_A_RELATION_ID_PREFIX + 
				startJpt.getName() + SEPARATOR + endJpt.getName();
	}
	
	public boolean equals(Object obj) {
		if (obj == null)
			return false;
		if (this.hashCode() != obj.hashCode())
			return false;
		if (!(obj instanceof IsARelation))
			return false;
		IsARelation rel = (IsARelation)obj; 
		return this.getId().equals(rel.getId());
	}
	
	public int hashCode() {
		return getId().hashCode();
	}

}

Lines 24-30 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/ManyToManyBiDirRelation.java (-1 / +1 lines)
24	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;	24	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
25		25
26		26
27	public class ManyToManyBiDirRelation extends ManyToManyRelation implements BidirectionalRelation {	27	public class ManyToManyBiDirRelation extends ManyToManyRelation implements IBidirectionalRelation {
28		28
29	public ManyToManyBiDirRelation(IJPAEditorFeatureProvider fp, JavaPersistentType owner,	29	public ManyToManyBiDirRelation(IJPAEditorFeatureProvider fp, JavaPersistentType owner,
30	JavaPersistentType inverse,	30	JavaPersistentType inverse,

Lines 24-30 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/ManyToOneBiDirRelation.java (-1 / +1 lines)
24	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;	24	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
25		25
26		26
27	public class ManyToOneBiDirRelation extends ManyToOneRelation implements BidirectionalRelation{	27	public class ManyToOneBiDirRelation extends ManyToOneRelation implements IBidirectionalRelation{
28		28
29	public ManyToOneBiDirRelation(IJPAEditorFeatureProvider fp, JavaPersistentType owner,	29	public ManyToOneBiDirRelation(IJPAEditorFeatureProvider fp, JavaPersistentType owner,
30	JavaPersistentType inverse,	30	JavaPersistentType inverse,

Lines 23-29 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/OneToOneBiDirRelation.java (-2 / +1 lines)
23	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;	23	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
24		24
25		25
26	public class OneToOneBiDirRelation extends OneToOneRelation implements BidirectionalRelation{	26	public class OneToOneBiDirRelation extends OneToOneRelation implements IBidirectionalRelation{
27	public OneToOneBiDirRelation(IJPAEditorFeatureProvider fp, JavaPersistentType owner,	27	public OneToOneBiDirRelation(IJPAEditorFeatureProvider fp, JavaPersistentType owner,
28	JavaPersistentType inverse,	28	JavaPersistentType inverse,
29	String ownerAttributeName,	29	String ownerAttributeName,
Lines 59-65 Link Here
59	private void createRelation(IJPAEditorFeatureProvider fp, ICompilationUnit ownerCU, ICompilationUnit inverseCU) {	59	private void createRelation(IJPAEditorFeatureProvider fp, ICompilationUnit ownerCU, ICompilationUnit inverseCU) {
60	String name = JPAEditorUtil.returnSimpleName(inverse.getName());	60	String name = JPAEditorUtil.returnSimpleName(inverse.getName());
61	String actName = JPAEditorUtil.returnSimpleName(JpaArtifactFactory.instance().getEntityName(inverse));	61	String actName = JPAEditorUtil.returnSimpleName(JpaArtifactFactory.instance().getEntityName(inverse));
62
63	String nameWithNonCapitalLetter = JPAEditorUtil.decapitalizeFirstLetter(name);	62	String nameWithNonCapitalLetter = JPAEditorUtil.decapitalizeFirstLetter(name);
64	String actNameWithNonCapitalLetter = JPAEditorUtil.decapitalizeFirstLetter(actName);	63	String actNameWithNonCapitalLetter = JPAEditorUtil.decapitalizeFirstLetter(actName);
65		64




import java.util.Hashtable;
import java.util.Iterator;
import java.util.Set;

import org.eclipse.graphiti.features.context.impl.RemoveContext;
import org.eclipse.graphiti.mm.pictograms.ContainerShape;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jpt.common.core.resource.java.Annotation;
import org.eclipse.jpt.jpa.core.JptJpaCorePlugin;
import org.eclipse.jpt.jpa.core.context.MappedByRelationship;

						PersistenceUnit pu = JpaArtifactFactory.instance().getPersistenceUnit(jpt);
						PersistentType pt = pu.getPersistentType(jpt.getName());
						
						if ((pt == null) || !JpaArtifactFactory.instance().hasEntityOrMappedSuperclassAnnotation(jpt)) {
							
							JpaArtifactFactory.instance().forceSaveEntityClass(jpt, featureProvider);
							

							RemoveAndSaveEntityFeature ft = new RemoveAndSaveEntityFeature(featureProvider);
							ft.remove(ctx);
							break;
						} else {	
							
							ICompilationUnit cu = featureProvider.getCompilationUnit(jpt);
							String entName = JPAEditorUtil.returnSimpleName(JpaArtifactFactory.instance().getEntityName(jpt)); 
							try {
								final String newHeader = (cu.hasUnsavedChanges() ? "* " : "") + entName;	//$NON-NLS-1$ //$NON-NLS-2$
								Display.getDefault().asyncExec(new Runnable() {
									public void run() {
										GraphicsUpdater.updateHeader(entShape, newHeader);
									}
								});
												
							} catch (JavaModelException e) {
								JPADiagramEditorPlugin.logError("Cannot check compilation unit for unsaved changes", e); //$NON-NLS-1$				
							}								
						}
					}
				}		

					}
				}
			} catch(Exception e) {
				//ignore 
			}			
		}
	}




	}
	
	public static void updateHeader(ContainerShape entityShape, final String newHeader) {
		final Text txt = getHeaderText(entityShape);
		if (txt == null)
			return;
		//if (!JPAEditorUtil.areHeadersEqual(txt.getValue(), newHeader)) {

		if (!txt.getValue().equals(newHeader)) {
			TransactionalEditingDomain ted = TransactionUtil.getEditingDomain(txt);
			RecordingCommand rc = new RecordingCommand(ted) {
				protected void doExecute() {
					txt.setValue(newHeader);		
				}		
			};			
			ted.getCommandStack().execute(rc);
		}
	}
	
	private static Text getHeaderText(ContainerShape entityShape) {
		if(entityShape == null)
			return null;		
		List<Shape> shapes = entityShape.getChildren();
		Iterator<Shape> shIt = shapes.iterator();
		Shape headerShape = null;;

			headerShape = null;
		}
		if (headerShape == null)
			return null;
		GraphicsAlgorithm ga = headerShape.getGraphicsAlgorithm();
		if (ga == null)
			return null;
		if (ga.getGraphicsAlgorithmChildren().size() == 0)
			return null;
		Text txt = (Text)ga.getGraphicsAlgorithmChildren().get(0);
		return txt;
				protected void doExecute() {
					txt.setValue(newHeader);		
				}		
			};			
			ted.getCommandStack().execute(rc);
		}
	}
}




/*******************************************************************************
 * <copyright>
 *
 * Copyright (c) 2005, 2010 SAP AG.
 * 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:
 *    Stefan Dimov - initial API, implementation and documentation
 *
 * </copyright>
 *
 *******************************************************************************/
package org.eclipse.jpt.jpadiagrameditor.ui.internal.util;

import org.eclipse.graphiti.util.IPredefinedRenderingStyle;

public interface IJPAEditorPredefinedRenderingStyle extends IPredefinedRenderingStyle {

	/**
	 * The ID for a green-to-white gradient with a gloss-effect.
	 */
	public static final String GREEN_WHITE_GLOSS_ID = "green-white-gloss"; //$NON-NLS-1$
	
}

Lines 18-23 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/IJPAEditorUtil.java (+13 lines)
18	import java.util.List;	18	import java.util.List;
19		19
20	import org.eclipse.core.resources.IFile;	20	import org.eclipse.core.resources.IFile;
		21	import org.eclipse.core.resources.IFolder;
21	import org.eclipse.core.resources.IProject;	22	import org.eclipse.core.resources.IProject;
22	import org.eclipse.graphiti.mm.pictograms.ConnectionDecorator;	23	import org.eclipse.graphiti.mm.pictograms.ConnectionDecorator;
23	import org.eclipse.graphiti.mm.pictograms.FreeFormConnection;	24	import org.eclipse.graphiti.mm.pictograms.FreeFormConnection;
Lines 64-74 Link Here
64	boolean isMappedSuperClassChild,	65	boolean isMappedSuperClassChild,
65	String mappedSuperclassName,	66	String mappedSuperclassName,
66	String mappedSuperclassPackage,	67	String mappedSuperclassPackage,
		68	String idName,
67	boolean hasPrimaryKey) throws Exception;	69	boolean hasPrimaryKey) throws Exception;
		70
		71	public IFile createEntityInProject(IProject project,
		72	String entityName,
		73	JavaPersistentType mappedSuperclass) throws Exception;
		74
68		75
69	public IFile createEntityFromMappedSuperclassInProject(IProject project,	76	public IFile createEntityFromMappedSuperclassInProject(IProject project,
70	String mappedSuperclassName, IPreferenceStore jpaPreferenceStore) throws Exception;	77	String mappedSuperclassName, IPreferenceStore jpaPreferenceStore) throws Exception;
71		78
		79	public IFile createMappedSuperclassInProject(IProject project,
		80	IFolder folder, String mappedSuperclassName) throws Exception;
		81
		82	public IFile createMappedSuperclassInProject(IProject project,
		83	String mappedSuperclassName) throws Exception;
		84
72	public boolean isCardinalityDecorator(ConnectionDecorator cd);	85	public boolean isCardinalityDecorator(ConnectionDecorator cd);
73		86
74	public void discardWorkingCopyOnce(ICompilationUnit cu);	87	public void discardWorkingCopyOnce(ICompilationUnit cu);

Lines 25-30 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPAEditorConstants.java (+20 lines)
25		25
26	public class JPAEditorConstants {	26	public class JPAEditorConstants {
27		27
		28	public static enum DIAGRAM_OBJECT_TYPE {
		29	Entity,
		30	MappedSupeclass
		31	};
		32
		33	public static final String IS_A_RELATION_ID_PREFIX = "is_a_relation:"; //$NON-NLS-1$
		34
		35	public static final String IS_A = "is-a"; //$NON-NLS-1$
		36
28	public static final String HEADER_PREFIX_DIRTY = "* "; //$NON-NLS-1$	37	public static final String HEADER_PREFIX_DIRTY = "* "; //$NON-NLS-1$
29		38
30	public static Hashtable<String, String> PRIMITIVE_TO_WRAPPER = new Hashtable<String,String>();	39	public static Hashtable<String, String> PRIMITIVE_TO_WRAPPER = new Hashtable<String,String>();
Lines 41-56 Link Here
41		50
42	public static final IColorConstant ENTITY_BACKGROUND =	51	public static final IColorConstant ENTITY_BACKGROUND =
43	new ColorConstant(212, 231, 248);	52	new ColorConstant(212, 231, 248);
		53
		54	public static final IColorConstant MAPPED_SUPERCLASS_BACKGROUND =
		55	new ColorConstant(212, 248, 231);
44		56
45	public static final IColorConstant CONNECTION_LINE_COLOR =	57	public static final IColorConstant CONNECTION_LINE_COLOR =
46	new ColorConstant(98, 131,167);	58	new ColorConstant(98, 131,167);
47		59
		60	public static final IColorConstant IS_A_CONNECTION_LINE_COLOR =
		61	new ColorConstant(98, 167, 131);
		62
48	public static final IColorConstant ENTITY_BORDER_COLOR =	63	public static final IColorConstant ENTITY_BORDER_COLOR =
49	new ColorConstant(98, 131,167);	64	new ColorConstant(98, 131,167);
50		65
		66	public static final IColorConstant MAPPED_SUPERCLASS_BORDER_COLOR =
		67	new ColorConstant(98, 167, 131);
		68
51	public final static String TRUE_STRING = Boolean.toString(true);	69	public final static String TRUE_STRING = Boolean.toString(true);
52		70
53	public final static int CONNECTION_LINE_WIDTH = 2;	71	public final static int CONNECTION_LINE_WIDTH = 2;
		72	public final static int IS_A_CONNECTION_LINE_WIDTH = 2;
		73
54	public final static int ENTITY_BORDER_WIDTH = 2;	74	public final static int ENTITY_BORDER_WIDTH = 2;
55		75
56	public final static int ENTITY_CORNER_WIDTH = 6;	76	public final static int ENTITY_CORNER_WIDTH = 6;




/*******************************************************************************
 * <copyright>
 *
 * Copyright (c) 2005, 2010 SAP AG.
 * 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:
 *    Stefan Dimov - initial API, implementation and documentation
 *
 * </copyright>
 *
 *******************************************************************************/
package org.eclipse.jpt.jpadiagrameditor.ui.internal.util;

import org.eclipse.emf.common.util.EList;
import org.eclipse.graphiti.mm.algorithms.styles.AdaptedGradientColoredAreas;
import org.eclipse.graphiti.mm.algorithms.styles.GradientColoredArea;
import org.eclipse.graphiti.mm.algorithms.styles.GradientColoredAreas;
import org.eclipse.graphiti.mm.algorithms.styles.LocationType;
import org.eclipse.graphiti.mm.algorithms.styles.StylesFactory;
import org.eclipse.graphiti.util.IGradientType;
import org.eclipse.graphiti.util.IPredefinedRenderingStyle;
import org.eclipse.graphiti.util.PredefinedColoredAreas;

public class JPAEditorPredefinedColoredAreas extends PredefinedColoredAreas 
											 implements IJPAEditorPredefinedRenderingStyle {

	/**
	 * The color-areas, which are used for default elements with the ID
	 * {@link #GREEN_WHITE_GLOSS_ID}.
	 */
	private static GradientColoredAreas getGreenWhiteGlossDefaultAreas() {
		final GradientColoredAreas gradientColoredAreas = StylesFactory.eINSTANCE.createGradientColoredAreas();
		final EList<GradientColoredArea> gcas = gradientColoredAreas.getGradientColor();

		addGradientColoredArea(gcas, "F8FEFB", 0, LocationType.LOCATION_TYPE_ABSOLUTE_START, "F8FEFB", 1, //$NON-NLS-1$ //$NON-NLS-2$
				LocationType.LOCATION_TYPE_ABSOLUTE_START);
		addGradientColoredArea(gcas, "EDFCF5", 1, LocationType.LOCATION_TYPE_ABSOLUTE_START, "EDFCF5", 2, //$NON-NLS-1$ //$NON-NLS-2$
				LocationType.LOCATION_TYPE_ABSOLUTE_START);
		addGradientColoredArea(gcas, "DEFAED", 2, LocationType.LOCATION_TYPE_ABSOLUTE_START, "DEFAED", 3, //$NON-NLS-1$ //$NON-NLS-2$
				LocationType.LOCATION_TYPE_ABSOLUTE_START);
		addGradientColoredArea(gcas, "D4F8E7", 3, LocationType.LOCATION_TYPE_ABSOLUTE_START, "FAFCFB", 2, //$NON-NLS-1$ //$NON-NLS-2$
				LocationType.LOCATION_TYPE_ABSOLUTE_END);
		addGradientColoredArea(gcas, "E2E9E5", 2, LocationType.LOCATION_TYPE_ABSOLUTE_END, "E2E9E5", 0, //$NON-NLS-1$ //$NON-NLS-2$
				LocationType.LOCATION_TYPE_ABSOLUTE_END);
		gradientColoredAreas.setStyleAdaption(IPredefinedRenderingStyle.STYLE_ADAPTATION_DEFAULT);
		return gradientColoredAreas;
	}

	/**
	 * The color-areas, which are used for primary selected elements with the ID
	 * {@link #GREEN_WHITE_GLOSS_ID}.
	 */
	private static GradientColoredAreas getGreenWhiteGlossPrimarySelectedAreas() {
		final GradientColoredAreas gradientColoredAreas = StylesFactory.eINSTANCE.createGradientColoredAreas();
		gradientColoredAreas.setStyleAdaption(IPredefinedRenderingStyle.STYLE_ADAPTATION_PRIMARY_SELECTED);
		final EList<GradientColoredArea> gcas = gradientColoredAreas.getGradientColor();

		addGradientColoredArea(gcas, "EEFDF6", 0, LocationType.LOCATION_TYPE_ABSOLUTE_START, "EEFDF6", 1, //$NON-NLS-1$ //$NON-NLS-2$
				LocationType.LOCATION_TYPE_ABSOLUTE_START);
		addGradientColoredArea(gcas, "D0F9E6", 1, LocationType.LOCATION_TYPE_ABSOLUTE_START, "D0F9E6", 2, //$NON-NLS-1$ //$NON-NLS-2$
				LocationType.LOCATION_TYPE_ABSOLUTE_START);
		addGradientColoredArea(gcas, "ACF4D2", 2, LocationType.LOCATION_TYPE_ABSOLUTE_START, "ACF4D2", 3, //$NON-NLS-1$ //$NON-NLS-2$
				LocationType.LOCATION_TYPE_ABSOLUTE_START);
		addGradientColoredArea(gcas, "81EAB9", 3, LocationType.LOCATION_TYPE_ABSOLUTE_START, "AAF2D0", 2, //$NON-NLS-1$ //$NON-NLS-2$
				LocationType.LOCATION_TYPE_ABSOLUTE_END);
		addGradientColoredArea(gcas, "9AE0BF", 2, LocationType.LOCATION_TYPE_ABSOLUTE_END, "9AE0BF", 0, //$NON-NLS-1$ //$NON-NLS-2$
				LocationType.LOCATION_TYPE_ABSOLUTE_END);
		return gradientColoredAreas;
	}

	/**
	 * The color-areas, which are used for secondary selected elements with the
	 * ID {@link #GREEN_WHITE_GLOSS_ID}.
	 */
	private static GradientColoredAreas getGreenWhiteGlossSecondarySelectedAreas() {
		final GradientColoredAreas gradientColoredAreas = StylesFactory.eINSTANCE.createGradientColoredAreas();
		gradientColoredAreas.setStyleAdaption(IPredefinedRenderingStyle.STYLE_ADAPTATION_SECONDARY_SELECTED);
		final EList<GradientColoredArea> gcas = gradientColoredAreas.getGradientColor();

		addGradientColoredArea(gcas, "F5FEF9", 0, LocationType.LOCATION_TYPE_ABSOLUTE_START, "F5FEF9", 1, //$NON-NLS-1$ //$NON-NLS-2$
				LocationType.LOCATION_TYPE_ABSOLUTE_START);
		addGradientColoredArea(gcas, "E2FCEF", 1, LocationType.LOCATION_TYPE_ABSOLUTE_START, "E2FCEF", 2, //$NON-NLS-1$ //$NON-NLS-2$
				LocationType.LOCATION_TYPE_ABSOLUTE_START);
		addGradientColoredArea(gcas, "CBF9E3", 2, LocationType.LOCATION_TYPE_ABSOLUTE_START, "CBF9E3", 3, //$NON-NLS-1$ //$NON-NLS-2$
				LocationType.LOCATION_TYPE_ABSOLUTE_START);
		addGradientColoredArea(gcas, "BBF7DA", 3, LocationType.LOCATION_TYPE_ABSOLUTE_START, "C5F7E0", 2, //$NON-NLS-1$ //$NON-NLS-2$
				LocationType.LOCATION_TYPE_ABSOLUTE_END);
		addGradientColoredArea(gcas, "B2E5CD", 2, LocationType.LOCATION_TYPE_ABSOLUTE_END, "B2E5CD", 0, //$NON-NLS-1$ //$NON-NLS-2$
				LocationType.LOCATION_TYPE_ABSOLUTE_END);
		return gradientColoredAreas;
	}

	/**
	 * The color-areas, which are used for elements where an action is allowed
	 * with the ID {@link #GREEN_WHITE_GLOSS_ID}.
	 */
	private static GradientColoredAreas getGreeenWhiteGlossActionAllowedAreas() {
		final GradientColoredAreas gradientColoredAreas = StylesFactory.eINSTANCE.createGradientColoredAreas();
		gradientColoredAreas.setStyleAdaption(IPredefinedRenderingStyle.STYLE_ADAPTATION_ACTION_ALLOWED);
		final EList<GradientColoredArea> gcas = gradientColoredAreas.getGradientColor();

		addGradientColoredArea(gcas, "9900CC", 0, LocationType.LOCATION_TYPE_ABSOLUTE_START, "336699", 0, //$NON-NLS-1$ //$NON-NLS-2$
				LocationType.LOCATION_TYPE_ABSOLUTE_END);
		return gradientColoredAreas;
	}

	/**
	 * The color-areas, which are used for elements where an action is forbidden
	 * with the ID {@link #GREEN_WHITE_GLOSS_ID}.
	 */
	private static GradientColoredAreas getGreenWhiteGlossActionForbiddenAreas() {
		final GradientColoredAreas gradientColoredAreas = StylesFactory.eINSTANCE.createGradientColoredAreas();
		gradientColoredAreas.setStyleAdaption(IPredefinedRenderingStyle.STYLE_ADAPTATION_ACTION_FORBIDDEN);
		final EList<GradientColoredArea> gcas = gradientColoredAreas.getGradientColor();

		addGradientColoredArea(gcas, "FF00CC", 0, LocationType.LOCATION_TYPE_ABSOLUTE_START, "FF0066", 0, //$NON-NLS-1$ //$NON-NLS-2$
				LocationType.LOCATION_TYPE_ABSOLUTE_END);
		return gradientColoredAreas;
	}
	
	
	public static AdaptedGradientColoredAreas getGreenWhiteGlossAdaptions() {
		final AdaptedGradientColoredAreas agca = StylesFactory.eINSTANCE.createAdaptedGradientColoredAreas();
		agca.setDefinedStyleId(GREEN_WHITE_GLOSS_ID);
		agca.setGradientType(IGradientType.VERTICAL);
		agca.getAdaptedGradientColoredAreas().add(IPredefinedRenderingStyle.STYLE_ADAPTATION_DEFAULT, getGreenWhiteGlossDefaultAreas());
		agca.getAdaptedGradientColoredAreas().add(IPredefinedRenderingStyle.STYLE_ADAPTATION_PRIMARY_SELECTED,
				getGreenWhiteGlossPrimarySelectedAreas());
		agca.getAdaptedGradientColoredAreas().add(IPredefinedRenderingStyle.STYLE_ADAPTATION_SECONDARY_SELECTED,
				getGreenWhiteGlossSecondarySelectedAreas());
		agca.getAdaptedGradientColoredAreas().add(IPredefinedRenderingStyle.STYLE_ADAPTATION_ACTION_ALLOWED,
				getGreeenWhiteGlossActionAllowedAreas());
		agca.getAdaptedGradientColoredAreas().add(IPredefinedRenderingStyle.STYLE_ADAPTATION_ACTION_FORBIDDEN,
				getGreenWhiteGlossActionForbiddenAreas());
		return agca;
	}	

	public static AdaptedGradientColoredAreas getAdaptedGradientColoredAreas(String id) {
		AdaptedGradientColoredAreas res = PredefinedColoredAreas.getAdaptedGradientColoredAreas(id);
		if (res != null)
			return res;
		if (GREEN_WHITE_GLOSS_ID.equals(id))
			return getGreenWhiteGlossAdaptions();
		return null;
	}
}

Lines 159-165 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPAEditorUtil.java (-35 / +69 lines)
159		159
160	public static Anchor getAnchor(ContainerShape cs) {	160	public static Anchor getAnchor(ContainerShape cs) {
161	Collection<Anchor> anchors = cs.getAnchors();	161	Collection<Anchor> anchors = cs.getAnchors();
162	return anchors.iterator().next();	162	if (anchors.iterator().hasNext())
		163	return anchors.iterator().next();
		164	return null;
163	}	165	}
164		166
165	public static Anchor getAnchor(JavaPersistentType jpt, IFeatureProvider fp) {	167	public static Anchor getAnchor(JavaPersistentType jpt, IFeatureProvider fp) {
Lines 536-542 Link Here
536	Iterator<Connection> consIt = cons.iterator();	538	Iterator<Connection> consIt = cons.iterator();
537	while (consIt.hasNext()) {	539	while (consIt.hasNext()) {
538	Connection con = consIt.next();	540	Connection con = consIt.next();
539	ContainerShape cs1 = (ContainerShape)con.getStart().getParent();	541	ContainerShape cs1 = null;
		542	try {
		543	cs1 = (ContainerShape)con.getStart().getParent();
		544	} catch (NullPointerException e) {
		545	continue;
		546	}
540	if (cs1 != cs)	547	if (cs1 != cs)
541	res.add(cs1);	548	res.add(cs1);
542	cs1 = (ContainerShape)con.getEnd().getParent();	549	cs1 = (ContainerShape)con.getEnd().getParent();
Lines 847-853 Link Here
847	Iterator<Connection> cIter = set.iterator();	854	Iterator<Connection> cIter = set.iterator();
848	while (cIter.hasNext()) {	855	while (cIter.hasNext()) {
849	Connection c = cIter.next();	856	Connection c = cIter.next();
850	IRelation rel = (IRelation)fp.getBusinessObjectForPictogramElement(c);	857	Object o = fp.getBusinessObjectForPictogramElement(c);
		858	if (!(o instanceof IRelation))
		859	continue;
		860	IRelation rel = (IRelation)o;
851	rearrangeConnection(c, cnt, setSize, rel.getOwner() == rel.getInverse());	861	rearrangeConnection(c, cnt, setSize, rel.getOwner() == rel.getInverse());
852	cnt++;	862	cnt++;
853	}	863	}
Lines 1067-1073 Link Here
1067		1077
1068	static public String generateUniqueMappedSuperclassName(	1078	static public String generateUniqueMappedSuperclassName(
1069	JpaProject jpaProject, String pack, IJPAEditorFeatureProvider fp) {	1079	JpaProject jpaProject, String pack, IJPAEditorFeatureProvider fp) {
1070	String NAME = pack + ".MappedSuperclass"; //$NON-NLS-1$	1080	String NAME = pack + ".MpdSuprcls"; //$NON-NLS-1$
1071	String name = null;	1081	String name = null;
1072		1082
1073	HashSet<String> JPAProjectEntityNames = getEntityNames(jpaProject);	1083	HashSet<String> JPAProjectEntityNames = getEntityNames(jpaProject);
Lines 1084-1100 Link Here
1084	return name;	1094	return name;
1085	}	1095	}
1086		1096
1087		1097	static public IFile createEntityInProject(IProject project,
		1098	String entityName,
		1099	JavaPersistentType mappedSuperclass) throws Exception {
		1100	IFolder folder = getPackageFolder(project);
		1101	return createEntity(project, folder, entityName,
		1102	true, mappedSuperclass.getName(),
		1103	JpaArtifactFactory.instance().getMappedSuperclassPackageDeclaration(mappedSuperclass),
		1104	JpaArtifactFactory.instance().generateIdName(mappedSuperclass),
		1105	JpaArtifactFactory.instance().hasOrInheritsPrimaryKey(mappedSuperclass));
		1106	}
1088		1107
1089	static public IFile createEntityInProject(IProject project,	1108	static public IFile createEntityInProject(IProject project,
1090	String entityName, IPreferenceStore jpaPreferenceStore,	1109	String entityName, IPreferenceStore jpaPreferenceStore,
1091	boolean isMappedSuperclassChild, String mappedSuperclassName,	1110	boolean isMappedSuperclassChild, String mappedSuperclassName,
1092	String mappedSuperclassPackage, boolean hasPrimaryKey)	1111	String mappedSuperclassPackage, String idName, boolean hasPrimaryKey)
1093	throws Exception {	1112	throws Exception {
1094	IFolder folder = getPackageFolder(project);	1113	IFolder folder = getPackageFolder(project);
1095	return createEntity(project, folder, entityName,	1114	return createEntity(project, folder, entityName,
1096	isMappedSuperclassChild, mappedSuperclassName,	1115	isMappedSuperclassChild, mappedSuperclassName,
1097	mappedSuperclassPackage, hasPrimaryKey);	1116	mappedSuperclassPackage, idName, hasPrimaryKey);
1098	}	1117	}
1099		1118
1100		1119
Lines 1102-1109 Link Here
1102	IProject project, String mappedSuperclassName,	1121	IProject project, String mappedSuperclassName,
1103	IPreferenceStore jpaPreferenceStore) throws Exception {	1122	IPreferenceStore jpaPreferenceStore) throws Exception {
1104	IFolder folder = getPackageFolder(project);	1123	IFolder folder = getPackageFolder(project);
1105	createMappedSuperclass(project, folder, mappedSuperclassName);	1124	return createMappedSuperclassInProject(project, folder, mappedSuperclassName);
1106	return createMappedSuperclass(project, folder, mappedSuperclassName);
1107	}	1125	}
1108		1126
1109	@SuppressWarnings("deprecation")	1127	@SuppressWarnings("deprecation")
Lines 1130-1136 Link Here
1130		1148
1131	}	1149	}
1132		1150
1133	static private IFile createMappedSuperclass(IProject project,	1151	static public IFile createMappedSuperclassInProject(IProject project,
		1152	String mappedSuperclassName) throws Exception {
		1153	IFolder folder = getPackageFolder(project);
		1154	return createMappedSuperclassInProject(project, folder, mappedSuperclassName);
		1155	}
		1156
		1157	static public IFile createMappedSuperclassInProject(IProject project,
1134	IFolder folder, String mappedSuperclassName) throws Exception {	1158	IFolder folder, String mappedSuperclassName) throws Exception {
1135		1159
1136	String mappedSuperclassShortName = mappedSuperclassName	1160	String mappedSuperclassShortName = mappedSuperclassName
Lines 1275-1284 Link Here
1275	}	1299	}
1276	}	1300	}
1277		1301
1278	static private IFile createEntity(IProject project, IFolder folder, String entityName, boolean isMappedSuperclassChild,	1302	static private IFile createEntity(IProject project,
1279	String mappedSuperclassName, String mappedSuperclassPackage, boolean hasPrimaryKey) throws Exception {	1303	IFolder folder,
1280		1304	String entityName,
1281		1305	boolean isMappedSuperclassChild,
		1306	String mappedSuperclassName,
		1307	String mappedSuperclassPackage,
		1308	String idName,
		1309	boolean hasPrimaryKey) throws Exception {
1282		1310
1283	String entityShortName = entityName.substring(entityName.lastIndexOf('.') + 1);	1311	String entityShortName = entityName.substring(entityName.lastIndexOf('.') + 1);
1284	if (!folder.exists()) {	1312	if (!folder.exists()) {
Lines 1306-1333 Link Here
1306	}	1334	}
1307		1335
1308	String primaryKeyDeclaration = ""; //$NON-NLS-1$	1336	String primaryKeyDeclaration = ""; //$NON-NLS-1$
1309	if (!hasPrimaryKey) {	1337	if (!hasPrimaryKey)
1310	primaryKeyDeclaration = (fieldBasedAccess ? " @Id \n" : "") //$NON-NLS-1$ //$NON-NLS-2$	1338	primaryKeyDeclaration = generatePrimaryKeyDeclaration(fieldBasedAccess, idName);
1311	+ " private long id;\n\n" //$NON-NLS-1$
1312	+ (fieldBasedAccess ? "" : " @Id \n") //$NON-NLS-1$ //$NON-NLS-2$
1313	+ " public long getId() {\n" //$NON-NLS-1$
1314	+ " return id;\n" //$NON-NLS-1$
1315	+ " }\n\n" //$NON-NLS-1$
1316	+ " public void setId(long id) {\n" //$NON-NLS-1$
1317	+ " this.id = id;\n" //$NON-NLS-1$
1318	+ " }\n\n"; //$NON-NLS-1$
1319	}
1320
1321		1339
1322	if (!file.exists()) {	1340	if (!file.exists()) {
1323	String content = "package " + JPADiagramPropertyPage.getDefaultPackage(project, props) + ";\n\n" //$NON-NLS-1$ //$NON-NLS-2$	1341	String content = "package " + JPADiagramPropertyPage.getDefaultPackage(project, props) //$NON-NLS-1$
1324	+ "import javax.persistence.*;\n" //$NON-NLS-1$	1342	+ ";\n\n" //$NON-NLS-1$
1325	+ packageImport+"\n\n" //$NON-NLS-1$	1343	+ "import javax.persistence.*;\n" //$NON-NLS-1$
1326	+ "@Entity \n" //$NON-NLS-1$	1344	+ packageImport+"\n\n" //$NON-NLS-1$
1327	+ ((tableName.length() > 0) ? ("@Table(name=\"" + tableName + "\")\n") : "") //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$	1345	+ "@Entity \n" //$NON-NLS-1$
1328	+ classDeclarationStringContent	1346	+ ((tableName.length() > 0) ? ("@Table(name=\"" //$NON-NLS-1$
1329	+ primaryKeyDeclaration	1347	+ tableName + "\")\n") : "") //$NON-NLS-1$ //$NON-NLS-2$
1330	+"}"; //$NON-NLS-1$	1348	+ classDeclarationStringContent
		1349	+ primaryKeyDeclaration
		1350	+"}"; //$NON-NLS-1$
1331	ByteArrayOutputStream stream = new ByteArrayOutputStream();	1351	ByteArrayOutputStream stream = new ByteArrayOutputStream();
1332	try {	1352	try {
1333	stream.write(content.getBytes());	1353	stream.write(content.getBytes());
Lines 1338-1344 Link Here
1338	}	1358	}
1339	}	1359	}
1340	return file;	1360	return file;
1341	}	1361	}
		1362
		1363	static private String generatePrimaryKeyDeclaration(boolean fieldBasedAccess, String primaryKeyName) {
		1364	String primaryKeyDeclaration = (fieldBasedAccess ? " @Id \n" : "") //$NON-NLS-1$ //$NON-NLS-2$
		1365	+ " private long " + primaryKeyName + ";\n\n" //$NON-NLS-1$ //$NON-NLS-2$
		1366	+ (fieldBasedAccess ? "" : " @Id \n") //$NON-NLS-1$ //$NON-NLS-2$
		1367	+ " public long get" + capitalizeFirstLetter(primaryKeyName) + "() {\n" //$NON-NLS-1$ //$NON-NLS-2$
		1368	+ " return " + primaryKeyName + ";\n" //$NON-NLS-1$ //$NON-NLS-2$
		1369	+ " }\n\n" //$NON-NLS-1$
		1370	+ " public void set" + capitalizeFirstLetter(primaryKeyName) //$NON-NLS-1$
		1371	+ "(long " + primaryKeyName + ") {\n" //$NON-NLS-1$ //$NON-NLS-2$
		1372	+ " this." + primaryKeyName + " = " + primaryKeyName + ";\n" //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		1373	+ " }\n\n"; //$NON-NLS-1$
		1374	return primaryKeyDeclaration;
		1375	}
1342		1376
1343	static private HashSet<String> getEntityNames(JpaProject jpaProject) {	1377	static private HashSet<String> getEntityNames(JpaProject jpaProject) {
1344	HashSet<String> names = new HashSet<String>();	1378	HashSet<String> names = new HashSet<String>();

Lines 18-23 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPAEditorUtilImpl.java (-2 / +20 lines)
18	import java.util.List;	18	import java.util.List;
19		19
20	import org.eclipse.core.resources.IFile;	20	import org.eclipse.core.resources.IFile;
		21	import org.eclipse.core.resources.IFolder;
21	import org.eclipse.core.resources.IProject;	22	import org.eclipse.core.resources.IProject;
22	import org.eclipse.graphiti.mm.pictograms.ConnectionDecorator;	23	import org.eclipse.graphiti.mm.pictograms.ConnectionDecorator;
23	import org.eclipse.graphiti.mm.pictograms.FreeFormConnection;	24	import org.eclipse.graphiti.mm.pictograms.FreeFormConnection;
Lines 78-88 Link Here
78		79
79		80
80	public IFile createEntityInProject(IProject project, String entityName, IPreferenceStore jpaPreferenceStore,	81	public IFile createEntityInProject(IProject project, String entityName, IPreferenceStore jpaPreferenceStore,
81	boolean isMappedSuperclassChild, String mappedSuperclassName, String mappedSuperclassPackage, boolean hasPrimaryKey) throws Exception {	82	boolean isMappedSuperclassChild, String mappedSuperclassName,
		83	String mappedSuperclassPackage, String idName,
		84	boolean hasPrimaryKey) throws Exception {
82	return JPAEditorUtil.createEntityInProject(project, entityName, jpaPreferenceStore, isMappedSuperclassChild,	85	return JPAEditorUtil.createEntityInProject(project, entityName, jpaPreferenceStore, isMappedSuperclassChild,
83	mappedSuperclassName, mappedSuperclassPackage, hasPrimaryKey);	86	mappedSuperclassName, mappedSuperclassPackage, idName, hasPrimaryKey);
84	}	87	}
85		88
		89	public IFile createEntityInProject(IProject project,
		90	String entityName,
		91	JavaPersistentType mappedSuperclass) throws Exception {
		92	return JPAEditorUtil.createEntityInProject(project, entityName, mappedSuperclass);
		93	}
86		94
87	public ICompilationUnit getCompilationUnit(JavaPersistentType jpt) {	95	public ICompilationUnit getCompilationUnit(JavaPersistentType jpt) {
88	return JPAEditorUtil.getCompilationUnit(jpt);	96	return JPAEditorUtil.getCompilationUnit(jpt);
Lines 100-104 Link Here
100	String mappedSuperclassName, IPreferenceStore jpaPreferenceStore) throws Exception {	108	String mappedSuperclassName, IPreferenceStore jpaPreferenceStore) throws Exception {
101	return JPAEditorUtil.createEntityFromMappedSuperclassInProject(project, mappedSuperclassName, jpaPreferenceStore);	109	return JPAEditorUtil.createEntityFromMappedSuperclassInProject(project, mappedSuperclassName, jpaPreferenceStore);
102	}	110	}
		111
		112	public IFile createMappedSuperclassInProject(IProject project,
		113	IFolder folder, String mappedSuperclassName) throws Exception {
		114	return JPAEditorUtil.createMappedSuperclassInProject(project, folder, mappedSuperclassName);
		115	}
		116
		117	public IFile createMappedSuperclassInProject(IProject project,
		118	String mappedSuperclassName) throws Exception {
		119	return JPAEditorUtil.createMappedSuperclassInProject(project, mappedSuperclassName);
		120	}
103		121
104	}	122	}




import java.util.List;
import java.util.Set;
import java.util.WeakHashMap;

import org.eclipse.core.internal.resources.File;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarkerDelta;

import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.JPAEditorDiagramTypeProvider;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.AbstractRelation;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IBidirectionalRelation;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Display;

	private IJPAEditorFeatureProvider featureProvider;
	private HashSet<String> removeIgnore = new HashSet<String>();
	private HashSet<String> removeRelIgnore = new HashSet<String>();
	private Collection<JavaPersistentType> persistentTypes = new HashSet<JavaPersistentType>();

	private HashSet<String> addIgnore = new HashSet<String>();
	private Hashtable<String, IRelation> attribToRel = new Hashtable<String, IRelation>();

			eclipseFacade.getDisplay().asyncExec(new Runnable() {
				public void run() {
					if(featureProvider != null)
						try {
							featureProvider.getDiagramTypeProvider().getDiagramEditor().refresh();
						} catch (Exception e) {
							// ignore
						}
				}
			});


			addListenersToEntity(jpt);
			PictogramElement pe = featureProvider.getPictogramElementForBusinessObject(jpt);
			Graphiti.getPeService().setPropertyValue(pe, JPAEditorConstants.PROP_ENTITY_CLASS_NAME, jpt.getName());
			persistentTypes.add(jpt);
		} else if (bo instanceof AbstractRelation) {
			AbstractRelation rel = (AbstractRelation) bo;
			attribToRel.put(produceOwnerKeyForRel(rel), rel);
			if (rel instanceof IBidirectionalRelation) {
				attribToRel.put(produceInverseKeyForRel(rel), rel);
			}
		} else if (bo instanceof JavaPersistentAttribute) {

				String k = getKeyForBusinessObject(at);
				remove(k);
			}
			persistentTypes.remove(jpt);
			removeListenersFromEntity(jpt);
			Diagram d = featureProvider.getDiagramTypeProvider().getDiagram();
			if (d.getChildren().size() == 1) {

		} else if (o instanceof AbstractRelation) {
			AbstractRelation rel = (AbstractRelation) o;
			attribToRel.remove(produceOwnerKeyForRel(rel));
			if (rel instanceof IBidirectionalRelation) 
				attribToRel.remove(produceInverseKeyForRel(rel));
		} else if (o instanceof JavaPersistentAttribute) {
			removeListenersFromAttribute((JavaPersistentAttribute)o);

		util = null;
		keyToBO.clear();
		attribToRel.clear();
		persistentTypes.clear();
		keyToBO = null;
		attribToRel = null;
		persistentTypes = null;
		removeAllListeners();
		featureProvider = null;
		synchronized (JPASolver.class) {

			
			for (ICompilationUnit cu : affectedCompilationUnits) {
				JavaPersistentType jpt = JPAEditorUtil.getJPType(cu);
				for (final JPASolver solver : solversSet) {
					final ContainerShape cs = (ContainerShape)solver.featureProvider.getPictogramElementForBusinessObject(jpt);
					if (cs == null)
						return;
					String entName = JPAEditorUtil.getText(jpt);
					try {
						final String newHeader = (cu.hasUnsavedChanges() ? "* " : "") + entName;	//$NON-NLS-1$ //$NON-NLS-2$
						GraphicsUpdater.updateHeader(cs, newHeader);
						JpaArtifactFactory.instance().rearrangeIsARelationsInTransaction(solver.featureProvider);
								GraphicsUpdater.updateHeader(cs, newHeader);
							}
						});
										
					} catch (JavaModelException e) {
						JPADiagramEditorPlugin.logError("Cannot check compilation unit for unsaved changes", e); //$NON-NLS-1$				 
					}
				}
			}
			}			
		}
		
		private Set<ICompilationUnit> getAffectedCompilationUnits(IJavaElementDelta delta) { 

		return resources;
	}

	public Collection<JavaPersistentType> getPersistentTypes() {
		return persistentTypes;
	}

}




import java.util.Locale;
import java.util.Properties;
import java.util.Set;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.emf.transaction.RecordingCommand;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.IRemoveContext;
import org.eclipse.graphiti.features.context.impl.AddConnectionContext;

import org.eclipse.graphiti.mm.pictograms.ContainerShape;
import org.eclipse.graphiti.mm.pictograms.Shape;
import org.eclipse.graphiti.services.Graphiti;
import org.eclipse.graphiti.util.IColorConstant;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IField;
import org.eclipse.jdt.core.IImportDeclaration;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IPackageDeclaration;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.dom.CompilationUnit;

import org.eclipse.jpt.jpa.core.context.java.JavaAttributeMapping;
import org.eclipse.jpt.jpa.core.context.java.JavaEntity;
import org.eclipse.jpt.jpa.core.context.java.JavaManyToManyMapping;
import org.eclipse.jpt.jpa.core.context.java.JavaMappedSuperclass;
import org.eclipse.jpt.jpa.core.context.java.JavaOneToManyMapping;
import org.eclipse.jpt.jpa.core.context.java.JavaOneToOneMapping;
import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;

import org.eclipse.jpt.jpa.core.context.persistence.PersistenceUnit;
import org.eclipse.jpt.jpa.core.resource.java.AttributeOverrideAnnotation;
import org.eclipse.jpt.jpa.core.resource.java.ColumnAnnotation;
import org.eclipse.jpt.jpa.core.resource.java.EmbeddedIdAnnotation;
import org.eclipse.jpt.jpa.core.resource.java.IdAnnotation;
import org.eclipse.jpt.jpa.core.resource.java.IdClassAnnotation;
import org.eclipse.jpt.jpa.core.resource.java.JoinColumnAnnotation;
import org.eclipse.jpt.jpa.core.resource.java.ManyToManyAnnotation;

import org.eclipse.jpt.jpa.core.resource.java.RelationshipMappingAnnotation;
import org.eclipse.jpt.jpa.core.resource.java.TableAnnotation;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.JPADiagramEditorPlugin;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.AddInheritedEntityFeature;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.AddRelationFeature;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.RemoveRelationFeature;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.UpdateAttributeFeature;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.i18n.JPAEditorMessages;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.propertypage.JPADiagramPropertyPage;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IBidirectionalRelation;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation.RelDir;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation.RelType;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IsARelation;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.ManyToManyBiDirRelation;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.ManyToManyUniDirRelation;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.ManyToOneBiDirRelation;

		return INSTANCE;
	}
	
	public void rearrangeIsARelations(IJPAEditorFeatureProvider fp) {
		Collection<IsARelation> isARels = produceAllMissingIsARelations(fp);
		addIsARelations(fp, isARels);
		fp.removeAllRedundantIsARelations();
	} 
	
	public void rearrangeIsARelationsInTransaction(final IJPAEditorFeatureProvider fp) {
		final Collection<IsARelation> isARels = produceAllMissingIsARelations(fp);
		if (!fp.existRedundantIsARelations() && (isARels.size() == 0))
			return;
		TransactionalEditingDomain ted = fp.getTransactionalEditingDomain();
		RecordingCommand rc = new RecordingCommand(ted) {
			protected void doExecute() {
				addIsARelations(fp, isARels);
				fp.removeAllRedundantIsARelations();
			}		
		};
		ted.getCommandStack().execute(rc);
	} 
	
		
	public Collection<IsARelation> produceAllMissingIsARelations(IJPAEditorFeatureProvider fp) {
		Collection<JavaPersistentType> persistentTypes = fp.getPersistentTypes();
		Collection<IsARelation> res = new HashSet<IsARelation>();
		Iterator<JavaPersistentType> it = persistentTypes.iterator(); 
		HashSet<IsARelation> allExistingIsARelations = fp.getAllExistingIsARelations();
		while (it.hasNext()) {
			JavaPersistentType jpt = it.next();
			JavaPersistentType superclass = fp.getFirstSuperclassBelongingToTheDiagram(jpt);
			if (superclass == null)
				continue;
			IsARelation newRel = new IsARelation(jpt, superclass);
			if (!allExistingIsARelations.contains(newRel))
				res.add(newRel);
		}
		return res;
	}
		
	public void addOneToOneUnidirectionalRelation(IFeatureProvider fp, JavaPersistentType jpt, 
												  JavaPersistentAttribute attribute) {
		addOneToOneRelation(fp, jpt, attribute, null, null,

									 IJPAEditorFeatureProvider fp) {
		ICompilationUnit cu = fp.getCompilationUnit(jpt);
		try {
			JpaProject jpaProject = jpt.getJpaProject();
			JPAEditorUtil.discardWorkingCopy(cu);
			cu.delete(true, new NullProgressMonitor());
			return true;			

		JavaResourceType jrpt = convertJPTToJRT(jpt);
		if (jrpt == null)
			return false;
		JavaTypeMapping jtm = jpt.getMapping();
		if (jtm == null)
			return false;
		if (jtm instanceof JavaEntity) {
			JavaEntity mapping = (JavaEntity)jtm;
			return (mapping.getSpecifiedName() != null);
		}
		return false;
							}
	

	}
	*/
	
	public boolean hasEntityOrMappedSuperclassAnnotation(JavaPersistentType jpt) {
		return hasEntityAnnotation(jpt) || hasMappedSuperclassAnnotation(jpt); 
	}
	
	public boolean hasEntityAnnotation(JavaPersistentType jpt) {
		return (jpt.getMappingKey() == MappingKeys.ENTITY_TYPE_MAPPING_KEY);
	}	
	
	public boolean hasMappedSuperclassAnnotation(JavaPersistentType jpt) {
		return (jpt.getMappingKey() == MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY);
	}		
	
	public String getSpecifiedEntityName(JavaPersistentType jpt){
		JavaTypeMapping jtm = jpt.getMapping();
		if (jtm instanceof JavaEntity) {
			JavaEntity gje = (JavaEntity)jtm;
		return gje.getSpecifiedName();
	}
		JavaMappedSuperclass jms = (JavaMappedSuperclass)jtm;
		return jms.getName();
	}
	
	public void renameEntity(JavaPersistentType jpt, String newName) {
		JavaTypeMapping jtm = jpt.getMapping();
		if (jtm instanceof JavaEntity) {
			JavaEntity gje = (JavaEntity)jtm;
		gje.setSpecifiedName(newName);	
	}
	}
	
	public JavaPersistentAttribute addAttribute(IJPAEditorFeatureProvider fp, JavaPersistentType jpt, 
			JavaPersistentType attributeType,  String attributeName,

		IRelation rel = fp.getRelationRelatedToAttribute(oldAt);
		String inverseJPAName = null;
		JavaPersistentType inverseJPT = null;
		if (IBidirectionalRelation.class.isInstance(rel)) {
			inverseJPT = rel.getInverse();
			if (inverseJPT != oldAt.getParent()) {
				pu = JpaArtifactFactory.INSTANCE.getPersistenceUnit(jpt);

		return res;
	}
	
	private IBidirectionalRelation produceBiDirRelation(JavaPersistentType jpt,
			JavaPersistentAttribute at, Annotation an,
			JavaPersistentType relJPT, JavaPersistentAttribute relAt,
			Annotation relAn, IJPAEditorFeatureProvider fp) {

			}
		}
		
		IBidirectionalRelation res = null;
		if (annotationName.equals(JPAEditorConstants.ANNOTATION_ONE_TO_ONE)) {
			if (!fp.doesRelationExist(jpt, relJPT, ownerAttrName, RelType.ONE_TO_ONE,
					RelDir.BI))

		Iterator<Connection> iter = Graphiti.getPeService().getAllConnections(cs).iterator();
		while (iter.hasNext()) {
			Connection conn = iter.next();
			String v = Graphiti.getPeService().getPropertyValue(conn, IsARelation.IS_A_CONNECTION_PROP_KEY);
			if (Boolean.TRUE.toString().equals(v))
				continue;
			IRemoveContext ctx = new RemoveContext(conn);
			ctxs.add(ctx);
		}

		}		
	}
	
	public void addIsARelations(IJPAEditorFeatureProvider fp,
								   Collection<IsARelation> rels) {
		Iterator<IsARelation> it = rels.iterator();
		while (it.hasNext()) {
			IsARelation rel = it.next();
			addNewIsARelation(fp, rel);
		}
	}
	
	private void addNewRelation(IJPAEditorFeatureProvider fp, IRelation rel) {
		AddConnectionContext ctx = new AddConnectionContext(JPAEditorUtil
				.getAnchor(rel.getOwner(), fp), JPAEditorUtil.getAnchor(rel

		ft.add(ctx);		
	}
	
	private void addNewIsARelation(IJPAEditorFeatureProvider fp, IsARelation rel) {
		AddConnectionContext ctx = new AddConnectionContext(JPAEditorUtil
				.getAnchor(rel.getSubclass(), fp), JPAEditorUtil.getAnchor(rel.getSuperclass(), fp));
		ctx.setNewObject(rel);
		ctx.setTargetContainer(fp.getDiagramTypeProvider().getDiagram());
		refreshEntityModel(fp, rel.getSubclass());
		refreshEntityModel(fp, rel.getSuperclass());
		AddInheritedEntityFeature ft = new AddInheritedEntityFeature(fp);
		ft.add(ctx);		
	}
	
	private String getRelTypeName(RelationshipMappingAnnotation an,
			JavaResourceAttribute jra) {
		String relTypeName = null;

		return res.toArray(ret);
	}
	
	// returns true even if the primary key is inherited
	public boolean hasOrInheritsPrimaryKey(JavaPersistentType jpt) {
		Iterable<ReadOnlyPersistentAttribute> attributes = jpt.getAllAttributes();
		Iterator<ReadOnlyPersistentAttribute> it = attributes.iterator();
		while (it.hasNext()) {
			ReadOnlyPersistentAttribute at = it.next();
			if (isId(at))
				return true;
		}
		return false;
	}
	
	public boolean hasPrimaryKey(JavaPersistentType jpt) {
		for (JavaPersistentAttribute at : jpt.getAttributes()) 
			if (isId(at)) return true;
		return false;
	}

	
	public boolean isId(ReadOnlyPersistentAttribute jpa) {
		return isSimpleId(jpa) || isEmbeddedId(jpa);
	}
	
	public boolean isSimpleId(ReadOnlyPersistentAttribute jpa) {
		return (jpa.getMappingKey() == MappingKeys.ID_ATTRIBUTE_MAPPING_KEY);
		return (an != null);
	}
	
	public boolean isEmbeddedId(ReadOnlyPersistentAttribute jpa) {
		return (jpa.getMappingKey() == MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY);
		return (an != null);
	}	
	
	public String getColumnName(JavaPersistentAttribute jpa) {

		return columnName; 
	}
	
	public IColorConstant getForeground(JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot) {
		IColorConstant foreground = dot.equals(JPAEditorConstants.DIAGRAM_OBJECT_TYPE.MappedSupeclass) ? 
				JPAEditorConstants.MAPPED_SUPERCLASS_BORDER_COLOR:
				JPAEditorConstants.ENTITY_BORDER_COLOR;
		return foreground;
	}

	public IColorConstant getBackground(JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot) {
		IColorConstant background = dot.equals(JPAEditorConstants.DIAGRAM_OBJECT_TYPE.MappedSupeclass) ? 
				JPAEditorConstants.MAPPED_SUPERCLASS_BACKGROUND:
				JPAEditorConstants.ENTITY_BACKGROUND;	
		return background;
	}
	
	public String getRenderingStyle(JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot) {
		String renderingStyle = dot.equals(JPAEditorConstants.DIAGRAM_OBJECT_TYPE.MappedSupeclass) ? 
			IJPAEditorPredefinedRenderingStyle.GREEN_WHITE_GLOSS_ID :
			IJPAEditorPredefinedRenderingStyle.BLUE_WHITE_GLOSS_ID;
		return renderingStyle;
	}
	
	public JPAEditorConstants.DIAGRAM_OBJECT_TYPE determineDiagramObjectType(JavaPersistentType jpt) {
		if (this.hasEntityAnnotation(jpt)) {
			return JPAEditorConstants.DIAGRAM_OBJECT_TYPE.Entity;
		} else if (this.hasMappedSuperclassAnnotation(jpt)) {
			return JPAEditorConstants.DIAGRAM_OBJECT_TYPE.MappedSupeclass;
		}
		throw new IllegalArgumentException();
	}
	
	public String generateIdName(JavaPersistentType jpt) {
		String name = "id";		//$NON-NLS-1$
		String genName = name;
		for (int i = 0; i < 10000000; i++) {
			if (!hasAttributeNamed(jpt, genName))
				return genName;
			genName = name + "_" + i;	//$NON-NLS-1$
		}
		return genName;
	}
	
	
	private  boolean hasAttributeNamed(JavaPersistentType jpt, String name) {
		Iterable<String> hier = jpt.getAllAttributeNames();
		Iterator<String> it = hier.iterator();
		while (it.hasNext()) {
			String atName = it.next();
			if (name.equals(atName))
				return true;
		}
		return false;
	}
	
	public String getMappedSuperclassPackageDeclaration(JavaPersistentType jpt) throws JavaModelException {
		String packageName = null;
		IPackageDeclaration[] packages = JPAEditorUtil.getCompilationUnit(jpt)
				.getPackageDeclarations();
		if (packages.length > 0) {
			IPackageDeclaration packageDecl = packages[0];
			packageName = packageDecl.getElementName();
		}
		return packageName;
	}
	
		
}




/*******************************************************************************
 * <copyright>
 *
 * Copyright (c) 2005, 2010 SAP AG.
 * 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:
 *    Stefan Dimov - initial API, implementation and documentation
 *
 * </copyright>
 *
 *******************************************************************************/
package org.eclipse.jpt.jpadiagrameditor.ui.internal.util;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.JPADiagramEditorPlugin;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.modelintegration.util.ModelIntegrationUtil;
import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.JPAEditorDiagramTypeProvider;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IWorkbenchPage;


	public void resourceChanged(IResourceChangeEvent event) {
		IMarkerDelta[] markerDeltas = event.findMarkerDeltas(null, true);
		IProject pr = null;
		for (IMarkerDelta delta : markerDeltas) {
			int resType = delta.getResource().getType();
			if (resType == IResource.PROJECT) {
				pr = (IProject)delta.getResource();
				continue;
			}
			if (resType != IResource.FILE)
				continue;
			final IFile file = (IFile) delta.getResource();
			pr = file.getProject();
			if (file.exists())
				continue;
			if (delta.getKind() != IResourceDelta.REMOVED) 
				continue;
			final IProject project = file.getProject();
			pr = project;
			final String name = project.getName();
			if (file.getFullPath().equals(ModelIntegrationUtil.getDiagramXMLFullPath(name))) {
				PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {

				});
				
			}
		}	
		
		if (pr == null)
			return;
		rearrangeIsARelations(pr);

	}
	
	private void rearrangeIsARelations(IProject pr) {
		if (pr == null) return;
		final Diagram d = ModelIntegrationUtil.getDiagramByProject(pr);
		if (d == null) return;
		final JPAEditorDiagramTypeProvider provider = ModelIntegrationUtil.getProviderByDiagram(d.getName());
		if (provider == null)
			return;
		PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
			public void run() {
				JpaArtifactFactory.instance().rearrangeIsARelationsInTransaction(provider.getFeatureProvider());
			}
		});
		
	}
		
}

Lines 83-89 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/AllJpaEditorTests.java (-1 / +1 lines)
83	@BeforeClass	83	@BeforeClass
84	public static void verifyRequiredJarsExists() throws NoSuchElementException {	84	public static void verifyRequiredJarsExists() throws NoSuchElementException {
85	verifyJpaJarExists();	85	verifyJpaJarExists();
86	verifyEclipseLinkJarExists();	86	//verifyEclipseLinkJarExists();
87	}	87	}
88		88
89	private static void verifyJpaJarExists() throws NoSuchElementException {	89	private static void verifyJpaJarExists() throws NoSuchElementException {





	private IAddConnectionContext context;

	private IPeServiceUtil peServiceUtil;
	
	private IGaService gaUtil;
	

		diagramProvider = EasyMock.createMock(IDiagramTypeProvider.class);
		diagram = EasyMock.createMock(Diagram.class);
		context = EasyMock.createMock(IAddConnectionContext.class);
		peServiceUtil = EasyMock.createMock(IPeServiceUtil.class);
		gaUtil = EasyMock.createMock(IGaService.class);
		ft = EasyMock.createMock(IAddBendpointFeature.class);
		

		Polyline pl = EasyMock.createMock(Polyline.class);
		expect(pl.getX()).andReturn(0);
		expect(pl.getY()).andReturn(0);
		expect(imageCreator.createArrowConnectionDecorator(isA(Connection.class), eq(location), false)).andReturn(d);
		expect(d.getGraphicsAlgorithm()).andReturn(pl);
		replay(d, pl);
	}

	private void configureProvidersForAdd(IRelation relation) {
		expect(diagramProvider.getDiagram()).andReturn(diagram);
		expect(featureProvider.getDiagramTypeProvider()).andReturn(diagramProvider);
		expect(featureProvider.getPeServiceUtil()).andReturn(peServiceUtil);
		expect(featureProvider.getAddBendpointFeature(isA(IAddBendpointContext.class))).andStubReturn(ft);
		expect(context.getNewObject()).andReturn(relation);


		gaUtil.setLocation(isA(Polyline.class), EasyMock.anyInt() , EasyMock.anyInt());

		FreeFormConnection connection = createConnection(startAnchor, endAnchor);
		expect(peServiceUtil.createFreeFormConnection(diagram)).andReturn(connection);
		expect(imageCreator.createConnectionLine(diagram, connection)).andReturn(null);
		ft.addBendpoint(isA(IAddBendpointContext.class));
		

		replay(diagramProvider);
		replay(diagram);
		replay(context);
		replay(peServiceUtil);
		replay(gaUtil);
		replay(ft);
		return new AddRelationFeature(featureProvider, imageCreator, jpaEditorUtil);

Lines 45-51 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/feature/LayoutEntityFeatureTest.java (-1 / +1 lines)
45	EList<Shape> shList = new BasicInternalEList<Shape>(Shape.class);	45	EList<Shape> shList = new BasicInternalEList<Shape>(Shape.class);
46	EasyMock.expect(cs.getChildren()).andStubReturn(shList);	46	EasyMock.expect(cs.getChildren()).andStubReturn(shList);
47	IPeServiceUtil peUtil = EasyMock.createMock(IPeServiceUtil.class);	47	IPeServiceUtil peUtil = EasyMock.createMock(IPeServiceUtil.class);
48	EasyMock.expect(fp.getPeUtil()).andStubReturn(peUtil);	48	EasyMock.expect(fp.getPeServiceUtil()).andStubReturn(peUtil);
49	EasyMock.expect(peUtil.getProperty(cs, JPAEditorConstants.COLLAPSE_FEATURES)).andStubReturn(null);	49	EasyMock.expect(peUtil.getProperty(cs, JPAEditorConstants.COLLAPSE_FEATURES)).andStubReturn(null);
50	EasyMock.expect(peUtil.removeProperty(cs, JPAEditorConstants.COLLAPSE_FEATURES)).andStubReturn(false);	50	EasyMock.expect(peUtil.removeProperty(cs, JPAEditorConstants.COLLAPSE_FEATURES)).andStubReturn(false);
51	IGraphicsUpdater gu = EasyMock.createMock(IGraphicsUpdater.class);	51	IGraphicsUpdater gu = EasyMock.createMock(IGraphicsUpdater.class);

Return to bug 334142

Added Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/AddInheritedEntityFeature.java (+86 lines)
1	/*******************************************************************************
2	* <copyright>
3	*
4	* Copyright (c) 2005, 2010 SAP AG.
5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at
8	* http://www.eclipse.org/legal/epl-v10.html
9	*
10	* Contributors:
11	* Stefan Dimov - initial API, implementation and documentation
12	*
13	* </copyright>
14	*
15	*******************************************************************************/
16	package org.eclipse.jpt.jpadiagrameditor.ui.internal.feature;
17
18	import org.eclipse.graphiti.features.IFeatureProvider;
19	import org.eclipse.graphiti.features.context.IAddConnectionContext;
20	import org.eclipse.graphiti.features.context.IAddContext;
21	import org.eclipse.graphiti.features.impl.AbstractAddFeature;
22	import org.eclipse.graphiti.mm.pictograms.ConnectionDecorator;
23	import org.eclipse.graphiti.mm.pictograms.Diagram;
24	import org.eclipse.graphiti.mm.pictograms.FreeFormConnection;
25	import org.eclipse.graphiti.mm.pictograms.PictogramElement;
26	import org.eclipse.graphiti.services.Graphiti;
27	import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;
28	import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorImageCreator;
29	import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.JPAEditorImageCreator;
30	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IsARelation;
31	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.IJPAEditorUtil;
32	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorUtilImpl;
33
34	public class AddInheritedEntityFeature extends AbstractAddFeature {
35
36	private IJPAEditorImageCreator imageCreator;
37
38	public AddInheritedEntityFeature(IFeatureProvider fp) {
39	this(fp, new JPAEditorImageCreator(), new JPAEditorUtilImpl());
40	}
41
42
43	public AddInheritedEntityFeature(IFeatureProvider fp,
44	IJPAEditorImageCreator imageCreator,
45	IJPAEditorUtil jpaEditorUtil) {
46	super(fp);
47	this.imageCreator = imageCreator;
48	}
49
50
51	public boolean canAdd(IAddContext context) {
52	return true;
53	}
54
55	public PictogramElement add(IAddContext context) {
56	final IAddConnectionContext addConContext = (IAddConnectionContext) context;
57	final IsARelation relation = (IsARelation)context.getNewObject();
58	final Diagram diagram = getDiagram();
59	FreeFormConnection connection = createIsAConnection(addConContext, relation, diagram);
60	imageCreator.createIsAConnectionLine(diagram, connection);
61	layoutPictogramElement(connection);
62	return connection;
63	}
64
65	private FreeFormConnection createIsAConnection(IAddConnectionContext addConContext, IsARelation relation,
66	final Diagram diagram) {
67	FreeFormConnection connection = getFeatureProvider().getPeService().createFreeFormConnection(diagram);
68	connection.setStart(addConContext.getSourceAnchor());
69	connection.setEnd(addConContext.getTargetAnchor());
70	connection.setVisible(true);
71	connection.setActive(true);
72	getFeatureProvider().getPeServiceUtil().setPropertyValue(connection, IsARelation.IS_A_CONNECTION_PROP_KEY, Boolean.TRUE.toString());
73	addDecorators(connection);
74	return connection;
75	}
76
77	public IJPAEditorFeatureProvider getFeatureProvider() {
78	return (IJPAEditorFeatureProvider)super.getFeatureProvider();
79	}
80
81	private void addDecorators(FreeFormConnection c) {
82	ConnectionDecorator d = imageCreator.createArrowConnectionDecorator(c, 0.9999, true);
83	Graphiti.getGaService().setLocation(d.getGraphicsAlgorithm(), 0, 0);
84	}
85
86	}

Lines 18-27 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/AddJPAEntityFeature.java (-81 / +48 lines)
18	import java.util.ArrayList;	18	import java.util.ArrayList;
19	import java.util.HashSet;	19	import java.util.HashSet;
20	import java.util.List;	20	import java.util.List;
		21
21	import org.eclipse.graphiti.features.IFeatureProvider;	22	import org.eclipse.graphiti.features.IFeatureProvider;
22	import org.eclipse.graphiti.features.context.IAddContext;	23	import org.eclipse.graphiti.features.context.IAddContext;
23	import org.eclipse.graphiti.features.context.ICreateContext;
24	import org.eclipse.graphiti.features.context.impl.CreateContext;
25	import org.eclipse.graphiti.features.impl.AbstractAddShapeFeature;	24	import org.eclipse.graphiti.features.impl.AbstractAddShapeFeature;
26	import org.eclipse.graphiti.mm.algorithms.Image;	25	import org.eclipse.graphiti.mm.algorithms.Image;
27	import org.eclipse.graphiti.mm.algorithms.Polyline;	26	import org.eclipse.graphiti.mm.algorithms.Polyline;
Lines 35-49 Link Here
35	import org.eclipse.graphiti.mm.pictograms.PictogramElement;	34	import org.eclipse.graphiti.mm.pictograms.PictogramElement;
36	import org.eclipse.graphiti.mm.pictograms.Shape;	35	import org.eclipse.graphiti.mm.pictograms.Shape;
37	import org.eclipse.graphiti.services.Graphiti;	36	import org.eclipse.graphiti.services.Graphiti;
38	import org.eclipse.graphiti.util.IPredefinedRenderingStyle;	37	import org.eclipse.graphiti.util.IColorConstant;
39	import org.eclipse.graphiti.util.PredefinedColoredAreas;
40	import org.eclipse.jdt.core.ICompilationUnit;	38	import org.eclipse.jdt.core.ICompilationUnit;
41	import org.eclipse.jdt.core.IPackageDeclaration;
42	import org.eclipse.jdt.core.JavaModelException;	39	import org.eclipse.jdt.core.JavaModelException;
43	import org.eclipse.jdt.internal.core.SourceType;	40	import org.eclipse.jdt.internal.core.SourceType;
44	import org.eclipse.jpt.jpa.core.JpaProject;	41	import org.eclipse.jpt.jpa.core.JpaProject;
45	import org.eclipse.jpt.jpa.core.context.AttributeMapping;
46	import org.eclipse.jpt.jpa.core.context.java.JavaMappedSuperclass;
47	import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;	42	import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
48	import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;	43	import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
49	import org.eclipse.jpt.jpadiagrameditor.ui.internal.JPADiagramEditorPlugin;	44	import org.eclipse.jpt.jpadiagrameditor.ui.internal.JPADiagramEditorPlugin;
Lines 54-75 Link Here
54	import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.JPAEditorImageProvider;	49	import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.JPAEditorImageProvider;
55	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.GraphicsUpdater;	50	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.GraphicsUpdater;
56	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorConstants;	51	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorConstants;
		52	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorConstants.ShapeType;
		53	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorPredefinedColoredAreas;
57	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorUtil;	54	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorUtil;
58	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;	55	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
59	import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorConstants.ShapeType;
60		56
61		57
62	@SuppressWarnings({ "restriction" })	58	@SuppressWarnings({ "restriction" })
63	public class AddJPAEntityFeature extends AbstractAddShapeFeature {	59	public class AddJPAEntityFeature extends AbstractAddShapeFeature {
64		60
65	private IPeUtilFacade facade;	61	private IPeUtilFacade facade;
		62	private boolean shouldRearrangeIsARelations = true;
66	private static ContainerShape primaryShape;	63	private static ContainerShape primaryShape;
67	private static ContainerShape relationShape;	64	private static ContainerShape relationShape;
68	private static ContainerShape basicShape;	65	private static ContainerShape basicShape;
69		66
70		67
71	public AddJPAEntityFeature(IFeatureProvider fp) {	68	public AddJPAEntityFeature(IFeatureProvider fp, boolean shouldRearrangeIsARelations) {
72	super(fp);	69	super(fp);
		70	this.shouldRearrangeIsARelations = shouldRearrangeIsARelations;
73	facade = new PeUtilFacade();	71	facade = new PeUtilFacade();
74	}	72	}
75		73
Lines 126-140 Link Here
126	JavaPersistentType jpt = null;	124	JavaPersistentType jpt = null;
127	if (newObj instanceof JavaPersistentType) {	125	if (newObj instanceof JavaPersistentType) {
128	jpt = (JavaPersistentType) newObj;	126	jpt = (JavaPersistentType) newObj;
129	if (jpt.getMapping() instanceof JavaMappedSuperclass) {
130	jpt = createEntityFromExistingMappedSuperclass(fp, jpt);
131	}
132	} else if (newObj instanceof ICompilationUnit) {	127	} else if (newObj instanceof ICompilationUnit) {
133	ICompilationUnit cu = (ICompilationUnit) newObj;	128	ICompilationUnit cu = (ICompilationUnit) newObj;
134	jpt = JPAEditorUtil.getJPType(cu);	129	jpt = JPAEditorUtil.getJPType(cu);
135	if (jpt.getMapping() instanceof JavaMappedSuperclass) {
136	jpt = createEntityFromExistingMappedSuperclass(fp, jpt);
137	}
138		130
139	} else if (newObj instanceof SourceType) {	131	} else if (newObj instanceof SourceType) {
140	ICompilationUnit cu = ((SourceType)newObj).getCompilationUnit();	132	ICompilationUnit cu = ((SourceType)newObj).getCompilationUnit();
Lines 144-151 Link Here
144		136
145	ContainerShape entityShape = facade.createContainerShape(targetDiagram, true);	137	ContainerShape entityShape = facade.createContainerShape(targetDiagram, true);
146		138
147	createEntityRectangle(context, entityShape,	139	JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot = JpaArtifactFactory.instance().determineDiagramObjectType(jpt);
148	this.getFeatureProvider().getDiagramTypeProvider().getDiagram());	140	createEntityRectangle(context, entityShape, dot,
		141	this.getFeatureProvider().getDiagramTypeProvider().getDiagram());
149	link(entityShape, jpt);	142	link(entityShape, jpt);
150	Shape shape = Graphiti.getPeService().createShape(entityShape, false);	143	Shape shape = Graphiti.getPeService().createShape(entityShape, false);
151	Polyline headerBottomLine = Graphiti.getGaService().createPolyline(shape, new int[] { 0,	144	Polyline headerBottomLine = Graphiti.getGaService().createPolyline(shape, new int[] { 0,
Lines 154-160 Link Here
154	.setForeground(manageColor(JPAEditorConstants.ENTITY_BORDER_COLOR));	147	.setForeground(manageColor(JPAEditorConstants.ENTITY_BORDER_COLOR));
155	headerBottomLine.setLineWidth(JPAEditorConstants.ENTITY_BORDER_WIDTH);	148	headerBottomLine.setLineWidth(JPAEditorConstants.ENTITY_BORDER_WIDTH);
156		149
157	addHeader(jpt, entityShape, JPAEditorConstants.ENTITY_WIDTH);	150	addHeader(jpt, entityShape, JPAEditorConstants.ENTITY_WIDTH, dot);
158		151
159	createCompartments(context, jpt, entityShape);	152	createCompartments(context, jpt, entityShape);
160	fillCompartments(jpt,entityShape);	153	fillCompartments(jpt,entityShape);
Lines 169-232 Link Here
169		162
170	UpdateAttributeFeature updateFeature = new UpdateAttributeFeature(fp);	163	UpdateAttributeFeature updateFeature = new UpdateAttributeFeature(fp);
171	updateFeature.reconnect(jpt);	164	updateFeature.reconnect(jpt);
172		165	if (shouldRearrangeIsARelations)
		166	JpaArtifactFactory.instance().rearrangeIsARelations(getFeatureProvider());
173	return entityShape;	167	return entityShape;
174	}	168	}
175
176	private JavaPersistentType createEntityFromExistingMappedSuperclass(
177	IJPAEditorFeatureProvider fp, JavaPersistentType jpt) {
178	ICreateContext cont = new CreateContext();
179	String packageName = null;
180	try {
181	packageName = getMappedSuperclassPackageDeclaration(fp, jpt,
182	packageName);
183	} catch (JavaModelException e) {
184	JPADiagramEditorPlugin.logError(e);
185	}
186
187	boolean hasPrimaryKey = hasMappedSuperclassPrimaryKeyAttribute(jpt);
188
189	CreateJPAEntityFeature createFeature = new CreateJPAEntityFeature(fp,
190	true, jpt.getName(), packageName, hasPrimaryKey);
191	Object[] objects = createFeature.create(cont);
192	if (objects.length != 0) {
193	Object obj = objects[0];
194	if (obj instanceof JavaPersistentType) {
195	jpt = (JavaPersistentType) obj;
196	}
197	}
198	return jpt;
199	}
200
201	private boolean hasMappedSuperclassPrimaryKeyAttribute(
202	JavaPersistentType jpt) {
203
204	for (AttributeMapping map : ((JavaMappedSuperclass) jpt.getMapping()).getAllAttributeMappings()) {
205	if (map.getPrimaryKeyColumnName() != null) {
206	return true;
207	}
208	}
209	return false;
210	}
211
212	private String getMappedSuperclassPackageDeclaration(
213	IJPAEditorFeatureProvider fp, JavaPersistentType jpt,
214	String packageName) throws JavaModelException {
215	IPackageDeclaration[] packages = fp.getCompilationUnit(jpt)
216	.getPackageDeclarations();
217	if (packages.length > 0) {
218	IPackageDeclaration packageDecl = packages[0];
219	packageName = packageDecl.getElementName();
220	}
221	return packageName;
222	}
223		169
224	private void createCompartments(IAddContext context, JavaPersistentType jpt,	170	private void createCompartments(IAddContext context, JavaPersistentType jpt,
225	ContainerShape entityShape) {	171	ContainerShape entityShape) {
226	primaryShape = createCompartmentRectangle(entityShape, JPAEditorConstants.ENTITY_MIN_HEIGHT, JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape);	172	JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot = JpaArtifactFactory.instance().determineDiagramObjectType(jpt);
227	relationShape = createCompartmentRectangle(entityShape, GraphicsUpdater.getNextCompartmentY(primaryShape) + JPAEditorConstants.SEPARATOR_HEIGHT,	173	primaryShape = createCompartmentRectangle(entityShape,
228	JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes);	174	JPAEditorConstants.ENTITY_MIN_HEIGHT,
229	basicShape = createCompartmentRectangle(entityShape, GraphicsUpdater.getNextCompartmentY(relationShape) + JPAEditorConstants.SEPARATOR_HEIGHT, JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes);	175	JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape,
		176	dot);
		177	relationShape = createCompartmentRectangle(entityShape,
		178	GraphicsUpdater.getNextCompartmentY(primaryShape) + JPAEditorConstants.SEPARATOR_HEIGHT,
		179	JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes,
		180	dot);
		181	basicShape = createCompartmentRectangle(entityShape,
		182	GraphicsUpdater.getNextCompartmentY(relationShape) + JPAEditorConstants.SEPARATOR_HEIGHT,
		183	JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
		184	dot);
230	if (IAddEntityContext.class.isInstance(context)) {	185	if (IAddEntityContext.class.isInstance(context)) {
231	IAddEntityContext entityContext = (IAddEntityContext) context;	186	IAddEntityContext entityContext = (IAddEntityContext) context;
232	GraphicsUpdater.setCollapsed(primaryShape, entityContext.isPrimaryCollapsed());	187	GraphicsUpdater.setCollapsed(primaryShape, entityContext.isPrimaryCollapsed());
Lines 255-261 Link Here
255	}	210	}
256		211
257	private ContainerShape createCompartmentRectangle(	212	private ContainerShape createCompartmentRectangle(
258	ContainerShape entityShape, int y, String attribTxt) {	213	ContainerShape entityShape, int y, String attribTxt,
		214	JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot) {
259	int width = entityShape.getGraphicsAlgorithm().getWidth();	215	int width = entityShape.getGraphicsAlgorithm().getWidth();
260	ContainerShape containerShape = Graphiti.getPeService().createContainerShape(	216	ContainerShape containerShape = Graphiti.getPeService().createContainerShape(
261	entityShape, false);	217	entityShape, false);
Lines 268-274 Link Here
268		224
269	UpdateAttributeFeature updateFeature = new UpdateAttributeFeature(getFeatureProvider());	225	UpdateAttributeFeature updateFeature = new UpdateAttributeFeature(getFeatureProvider());
270		226
271	updateFeature.addSeparatorsToShape(containerShape);	227	updateFeature.addSeparatorsToShape(containerShape, dot);
272		228
273	return containerShape;	229	return containerShape;
274	}	230	}
Lines 341-357 Link Here
341	}	297	}
342		298
343	public static RoundedRectangle createEntityRectangle(IAddContext context,	299	public static RoundedRectangle createEntityRectangle(IAddContext context,
344	ContainerShape entityShape, Diagram diagram) {	300	ContainerShape entityShape,
345		301	JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot,
		302	Diagram diagram) {
		303
		304	IColorConstant foreground = JpaArtifactFactory.instance().getForeground(dot);
		305	IColorConstant background = JpaArtifactFactory.instance().getBackground(dot);
		306	String renderingStyle = JpaArtifactFactory.instance().getRenderingStyle(dot);
		307
346	RoundedRectangle entityRectangle = Graphiti.getGaService().createRoundedRectangle(	308	RoundedRectangle entityRectangle = Graphiti.getGaService().createRoundedRectangle(
347	entityShape, JPAEditorConstants.ENTITY_CORNER_WIDTH,	309	entityShape, JPAEditorConstants.ENTITY_CORNER_WIDTH,
348	JPAEditorConstants.ENTITY_CORNER_HEIGHT);	310	JPAEditorConstants.ENTITY_CORNER_HEIGHT);
349	entityRectangle	311	entityRectangle
350	.setForeground(Graphiti.getGaService().manageColor(diagram, JPAEditorConstants.ENTITY_BORDER_COLOR));	312	.setForeground(Graphiti.getGaService().manageColor(diagram, foreground));
351	entityRectangle	313	entityRectangle
352	.setBackground(Graphiti.getGaService().manageColor(diagram, JPAEditorConstants.ENTITY_BACKGROUND));	314	.setBackground(Graphiti.getGaService().manageColor(diagram, background));
353	Graphiti.getGaService().setRenderingStyle(entityRectangle.getPictogramElement().getGraphicsAlgorithm(),	315	Graphiti.getGaService().setRenderingStyle(entityRectangle.getPictogramElement().getGraphicsAlgorithm(),
354	PredefinedColoredAreas.getAdaptedGradientColoredAreas(IPredefinedRenderingStyle.BLUE_WHITE_GLOSS_ID));	316	JPAEditorPredefinedColoredAreas.getAdaptedGradientColoredAreas(renderingStyle));
355	entityRectangle.setLineWidth(JPAEditorConstants.ENTITY_BORDER_WIDTH);	317	entityRectangle.setLineWidth(JPAEditorConstants.ENTITY_BORDER_WIDTH);
356	entityRectangle.setLineStyle(LineStyle.SOLID);	318	entityRectangle.setLineStyle(LineStyle.SOLID);
357	Graphiti.getGaService().setLocationAndSize(entityRectangle, context	319	Graphiti.getGaService().setLocationAndSize(entityRectangle, context
Lines 370-377 Link Here
370	}	332	}
371		333
372	private ContainerShape addHeader(JavaPersistentType addedWrapper,	334	private ContainerShape addHeader(JavaPersistentType addedWrapper,
373	ContainerShape entityShape, int width) {	335	ContainerShape entityShape,
374		336	int width,
		337	JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot) {
		338	String entityIconId = dot.equals(JPAEditorConstants.DIAGRAM_OBJECT_TYPE.Entity) ?
		339	JPAEditorImageProvider.JPA_ENTITY :
		340	JPAEditorImageProvider.MAPPED_SUPERCLASS;
		341
375	ContainerShape headerIconShape = Graphiti.getPeService().createContainerShape(	342	ContainerShape headerIconShape = Graphiti.getPeService().createContainerShape(
376	entityShape, false);	343	entityShape, false);
377	Rectangle iconRect = Graphiti.getGaService().createRectangle(headerIconShape);	344	Rectangle iconRect = Graphiti.getGaService().createRectangle(headerIconShape);
Lines 383-389 Link Here
383	iconRect.setHeight(JPAEditorConstants.HEADER_ICON_RECT_HEIGHT);	350	iconRect.setHeight(JPAEditorConstants.HEADER_ICON_RECT_HEIGHT);
384	iconRect.setY(0);	351	iconRect.setY(0);
385	Image headerIcon = Graphiti.getGaService().createImage(iconRect,	352	Image headerIcon = Graphiti.getGaService().createImage(iconRect,
386	JPAEditorImageProvider.JPA_ENTITY);	353	entityIconId);
387	Graphiti.getGaService().setLocationAndSize(headerIcon,	354	Graphiti.getGaService().setLocationAndSize(headerIcon,
388	JPAEditorConstants.ICON_HEADER_X,	355	JPAEditorConstants.ICON_HEADER_X,
389	JPAEditorConstants.ICON_HEADER_Y,	356	JPAEditorConstants.ICON_HEADER_Y,

Lines 103-109 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/AddRelationFeature.java (-3 / +3 lines)
103		103
104	private FreeFormConnection createConnection(IAddConnectionContext addConContext, IRelation relation,	104	private FreeFormConnection createConnection(IAddConnectionContext addConContext, IRelation relation,
105	final Diagram diagram) {	105	final Diagram diagram) {
106	FreeFormConnection connection = getFeatureProvider().getPeUtil().createFreeFormConnection(diagram);	106	FreeFormConnection connection = getFeatureProvider().getPeServiceUtil().createFreeFormConnection(diagram);
107	connection.setStart(addConContext.getSourceAnchor());	107	connection.setStart(addConContext.getSourceAnchor());
108	connection.setEnd(addConContext.getTargetAnchor());	108	connection.setEnd(addConContext.getTargetAnchor());
109	connection.setVisible(true);	109	connection.setVisible(true);
Lines 154-160 Link Here
154	double endCoefficient = 1.0 - startCoefficient;	154	double endCoefficient = 1.0 - startCoefficient;
155	int len = JPAEditorUtil.calcConnectionLength(c);	155	int len = JPAEditorUtil.calcConnectionLength(c);
156	if (UNI.equals(direction)) {	156	if (UNI.equals(direction)) {
157	ConnectionDecorator d = imageCreator.createArrowConnectionDecorator(c, endCoefficient);	157	ConnectionDecorator d = imageCreator.createArrowConnectionDecorator(c, endCoefficient, false);
158	Graphiti.getGaService().setLocation(d.getGraphicsAlgorithm(),Math.round(-len/10), 0);	158	Graphiti.getGaService().setLocation(d.getGraphicsAlgorithm(),Math.round(-len/10), 0);
159	}	159	}
160	}	160	}
Lines 175-181 Link Here
175	ConnectionDecorator d1 = imageCreator.createManyStartDecorator(c, startCoefficient);	175	ConnectionDecorator d1 = imageCreator.createManyStartDecorator(c, startCoefficient);
176	Graphiti.getGaService().setLocation(d1.getGraphicsAlgorithm(),Math.round(len/10), 0);	176	Graphiti.getGaService().setLocation(d1.getGraphicsAlgorithm(),Math.round(len/10), 0);
177	if (UNI.equals(direction)) {	177	if (UNI.equals(direction)) {
178	ConnectionDecorator d2 = imageCreator.createArrowConnectionDecorator(c, endCoefficient);	178	ConnectionDecorator d2 = imageCreator.createArrowConnectionDecorator(c, endCoefficient, false);
179	Graphiti.getGaService().setLocation(d2.getGraphicsAlgorithm(),Math.round(-len/10), 0);	179	Graphiti.getGaService().setLocation(d2.getGraphicsAlgorithm(),Math.round(-len/10), 0);
180	}	180	}
181	}	181	}

Lines 92-109 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/GraphicalRemoveAttributeFeature.java (-5 / +6 lines)
92	.getAnchors().iterator().next());	92	.getAnchors().iterator().next());
93	ctx.setNewObject(rel);	93	ctx.setNewObject(rel);
94	relF.add(ctx);	94	relF.add(ctx);
95	// JpaArtifactFactory.instance().refreshEntityModel(fp, jpt);
96	}	95	}
		96	JpaArtifactFactory.instance().rearrangeIsARelations(getFeatureProvider());
		97
97	}	98	}
98		99
99	@SuppressWarnings("deprecation")	100	@SuppressWarnings("deprecation")
100	private void readdCompartmentsChildren(JavaPersistentType javaPersistentType, ContainerShape entityShape,	101	private void readdCompartmentsChildren(JavaPersistentType javaPersistentType, ContainerShape entityShape,
101	ContainerShape primaryShape, ContainerShape relationShape, ContainerShape basicShape) {	102	ContainerShape primaryShape, ContainerShape relationShape, ContainerShape basicShape) {
102		103	JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot = JpaArtifactFactory.instance().determineDiagramObjectType(javaPersistentType);
103	UpdateAttributeFeature updateFeature = new UpdateAttributeFeature(getFeatureProvider());	104	UpdateAttributeFeature updateFeature = new UpdateAttributeFeature(getFeatureProvider());
104	updateFeature.addSeparatorsToShape(primaryShape);	105	updateFeature.addSeparatorsToShape(primaryShape, dot);
105	updateFeature.addSeparatorsToShape(relationShape);	106	updateFeature.addSeparatorsToShape(relationShape, dot);
106	updateFeature.addSeparatorsToShape(basicShape);	107	updateFeature.addSeparatorsToShape(basicShape, dot);
107		108
108	for (JavaPersistentAttribute attribute : javaPersistentType.getAttributes()) {	109	for (JavaPersistentAttribute attribute : javaPersistentType.getAttributes()) {
109	updateFeature.addAttributes(entityShape, attribute);	110	updateFeature.addAttributes(entityShape, attribute);

Lines 114-119 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/RefactorEntityFeature.java (-5 / +8 lines)
114	final Shape pict = (Shape)getFeatureProvider().getPictogramElementForBusinessObject(jpt);	114	final Shape pict = (Shape)getFeatureProvider().getPictogramElementForBusinessObject(jpt);
115	JavaPersistentType jpt = (JavaPersistentType)getFeatureProvider().	115	JavaPersistentType jpt = (JavaPersistentType)getFeatureProvider().
116	getBusinessObjectForPictogramElement(pict);	116	getBusinessObjectForPictogramElement(pict);
		117	final JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot = JpaArtifactFactory.instance().determineDiagramObjectType(jpt);
117	final PersistenceUnit pu = JpaArtifactFactory.instance().getPersistenceUnit(jpt);	118	final PersistenceUnit pu = JpaArtifactFactory.instance().getPersistenceUnit(jpt);
118	final Semaphore s = new Semaphore(0);	119	final Semaphore s = new Semaphore(0);
119	final JPAProjectListener lsnr = new JPAProjectListener(s);	120	final JPAProjectListener lsnr = new JPAProjectListener(s);
Lines 137-148 Link Here
137	ted.getCommandStack().execute(new RecordingCommand(ted) {	138	ted.getCommandStack().execute(new RecordingCommand(ted) {
138	@Override	139	@Override
139	protected void doExecute() {	140	protected void doExecute() {
140	remapEntity(oldName, pict, pu, rename, lsnr, getFeatureProvider());	141	remapEntity(oldName, pict, pu, rename, lsnr, dot, getFeatureProvider());
141	}	142	}
142	});	143	});
143	}	144	}
144		145
145	public void execute(ICustomContext context, String newName, ICompilationUnit cu, JavaPersistentType jpt) {	146	public void execute(ICustomContext context, String newName, ICompilationUnit cu, JavaPersistentType jpt) {
		147	final JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot = JpaArtifactFactory.instance().determineDiagramObjectType(jpt);
146	final String oldName = jpt.getName();	148	final String oldName = jpt.getName();
147	final Shape pict = (Shape)getFeatureProvider().getPictogramElementForBusinessObject(jpt);	149	final Shape pict = (Shape)getFeatureProvider().getPictogramElementForBusinessObject(jpt);
148	jpt = (JavaPersistentType)getFeatureProvider().	150	jpt = (JavaPersistentType)getFeatureProvider().
Lines 161-167 Link Here
161	ted.getCommandStack().execute(new RecordingCommand(ted) {	163	ted.getCommandStack().execute(new RecordingCommand(ted) {
162	@Override	164	@Override
163	protected void doExecute() {	165	protected void doExecute() {
164	remapEntity(oldName, pict, pu, true, lsnr, getFeatureProvider());	166	remapEntity(oldName, pict, pu, true, lsnr, dot, getFeatureProvider());
165	}	167	}
166	});	168	});
167	}	169	}
Lines 171-176 Link Here
171	final PersistenceUnit pu,	173	final PersistenceUnit pu,
172	final boolean rename,	174	final boolean rename,
173	final JPAProjectListener lsnr,	175	final JPAProjectListener lsnr,
		176	final JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot,
174	final IJPAEditorFeatureProvider fp) {	177	final IJPAEditorFeatureProvider fp) {
175	BusyIndicator.showWhile(Display.getCurrent(), new Runnable() {	178	BusyIndicator.showWhile(Display.getCurrent(), new Runnable() {
176	public void run() {	179	public void run() {
Lines 190-200 Link Here
190	cont.setY(y);	193	cont.setY(y);
191	cont.setWidth(width);	194	cont.setWidth(width);
192	cont.setHeight(height);	195	cont.setHeight(height);
193	RoundedRectangle rect = AddJPAEntityFeature.createEntityRectangle(cont, cs, fp.getDiagramTypeProvider().getDiagram());	196	RoundedRectangle rect = AddJPAEntityFeature.createEntityRectangle(cont, cs, dot, fp.getDiagramTypeProvider().getDiagram());
194	rect.setFilled(true);	197	rect.setFilled(true);
195		198
196	IRemoveContext ctx = new RemoveContext(pict);	199	IRemoveContext ctx = new RemoveContext(pict);
197	RemoveJPAEntityFeature ft = new RemoveJPAEntityFeature(fp);	200	RemoveJPAEntityFeature ft = new RemoveJPAEntityFeature(fp, true);
198		201
199	boolean primaryCollapsed = JPAEditorConstants.TRUE_STRING.equals(Graphiti.getPeService().getPropertyValue(pict, JPAEditorConstants.PRIMARY_COLLAPSED));	202	boolean primaryCollapsed = JPAEditorConstants.TRUE_STRING.equals(Graphiti.getPeService().getPropertyValue(pict, JPAEditorConstants.PRIMARY_COLLAPSED));
200	boolean relationCollapsed = JPAEditorConstants.TRUE_STRING.equals(Graphiti.getPeService().getPropertyValue(pict, JPAEditorConstants.RELATION_COLLAPSED));	203	boolean relationCollapsed = JPAEditorConstants.TRUE_STRING.equals(Graphiti.getPeService().getPropertyValue(pict, JPAEditorConstants.RELATION_COLLAPSED));
Lines 217-223 Link Here
217	addCtx.setY(y);	220	addCtx.setY(y);
218	addCtx.setWidth(width);	221	addCtx.setWidth(width);
219	addCtx.setHeight(height);	222	addCtx.setHeight(height);
220	AddJPAEntityFeature ft1 = new AddJPAEntityFeature(fp);	223	AddJPAEntityFeature ft1 = new AddJPAEntityFeature(fp, true);
221	ft.remove(ctx);	224	ft.remove(ctx);
222	ft1.add(addCtx);	225	ft1.add(addCtx);
223	PictogramElement pe = fp.getPictogramElementForBusinessObject(newJPT);	226	PictogramElement pe = fp.getPictogramElementForBusinessObject(newJPT);

Lines 43-60 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/RemoveJPAEntityFeature.java (-24 / +9 lines)
43		43
44	public class RemoveJPAEntityFeature extends DefaultRemoveFeature {	44	public class RemoveJPAEntityFeature extends DefaultRemoveFeature {
45		45
		46	private boolean shouldRearrangeIsARelations = true;
46		47
47	public RemoveJPAEntityFeature(IFeatureProvider fp) {	48	public RemoveJPAEntityFeature(IFeatureProvider fp, boolean shouldRearrangeIsARelations) {
48	super(fp);	49	super(fp);
		50	this.shouldRearrangeIsARelations = shouldRearrangeIsARelations;
49	}	51	}
50		52
51	public void preRemove(IRemoveContext context) {	53	public void preRemove(IRemoveContext context) {
52	PictogramElement pe = context.getPictogramElement();	54	PictogramElement pe = context.getPictogramElement();
53
54	// RestoreEntityFeature ft = new RestoreEntityFeature(getFeatureProvider());
55	// ICustomContext customContext = new CustomContext(new PictogramElement[] { pe });
56	// ft.execute(customContext);
57
58	final Object bo = getFeatureProvider().getBusinessObjectForPictogramElement(pe);	55	final Object bo = getFeatureProvider().getBusinessObjectForPictogramElement(pe);
59	Set<Shape> shapesForDeletion = new HashSet<Shape>();	56	Set<Shape> shapesForDeletion = new HashSet<Shape>();
60	if (bo instanceof JavaPersistentType) {	57	if (bo instanceof JavaPersistentType) {
Lines 75-94 Link Here
75	IRemoveContext ctx = new RemoveContext(it.next());	72	IRemoveContext ctx = new RemoveContext(it.next());
76	f.remove(ctx);	73	f.remove(ctx);
77	}	74	}
78	//---------------------------------------------------------------------	75	String name = ((PersistentType)bo).getName();
79	//--Workaround for https://bugs.eclipse.org/bugs/show_bug.cgi?id=281345	76	getFeatureProvider().remove(name, true);
80	//Job job = new Job("Remove JPA entity") { //$NON-NLS-1$
81	// protected IStatus run(IProgressMonitor monitor) {
82	String name = ((PersistentType)bo).getName();
83	getFeatureProvider().remove(name, true);
84	//return new Status(IStatus.OK,
85	// JPADiagramEditorPlugin.PLUGIN_ID,
86	// name + " is removed"); //$NON-NLS-1$
87
88	// }
89	//};
90	//job.schedule();
91	//---------------------------------------------------------------------
92	}	77	}
93	}	78	}
94		79
Lines 123-131 Link Here
123	super.execute(context);	108	super.execute(context);
124	}	109	}
125		110
126		111	public void postRemove(IRemoveContext context) {
127		112	if (shouldRearrangeIsARelations)
128		113	JpaArtifactFactory.instance().rearrangeIsARelations(getFeatureProvider());
129		114	}
130		115
131	}	116	}

Lines 36-53 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/i18n/JPAEditorMessages.java (-4 / +8 lines)
36	public static String CreateDiagramJob_createDiagramJobName;	36	public static String CreateDiagramJob_createDiagramJobName;
37	public static String CreateDiagramJob_getJPADiagramMonitorTaskName;	37	public static String CreateDiagramJob_getJPADiagramMonitorTaskName;
38		38
		39	public static String CreateIsARelationFeature_description;
		40	public static String CreateIsARelationFeature_name;
		41
39	public static String CreateJPAEntityFeature_createEntityErrorMsg;	42	public static String CreateJPAEntityFeature_createEntityErrorMsg;
40
41	public static String CreateJPAEntityFeature_createEntityErrorMsgTitle;	43	public static String CreateJPAEntityFeature_createEntityErrorMsgTitle;
42
43	public static String CreateJPAEntityFeature_createEntityErrorStatusMsg;	44	public static String CreateJPAEntityFeature_createEntityErrorStatusMsg;
44
45	public static String CreateJPAEntityFeature_jpaEntityFeatureDescription;	45	public static String CreateJPAEntityFeature_jpaEntityFeatureDescription;
46	public static String CreateJPAEntityFeature_jpaEntityFeatureName;	46	public static String CreateJPAEntityFeature_jpaEntityFeatureName;
47	public static String CreateJPAEntityFeature_jpaProjectSelectionDialogDescription;	47	public static String CreateJPAEntityFeature_jpaProjectSelectionDialogDescription;
48	public static String CreateJPAEntityFeature_jpaProjectSelectionDialogTitle;	48	public static String CreateJPAEntityFeature_jpaProjectSelectionDialogTitle;
49	public static String CreateJPAEntityFromMappedSuperclassFeature_createInheritedEntityFeatureDescription;	49	public static String CreateJPAEntityFromMappedSuperclassFeature_createInheritedEntityFeatureDescription;
50	public static String CreateJPAEntityFromMappedSuperclassFeature_createInheritedEntityFeatureName;	50	public static String CreateJPAEntityFromMappedSuperclassFeature_createInheritedEntityFeatureName;
		51	public static String CreateMappedSuperclassFeature_createMappedSuperclassFeatureDescription;
		52	public static String CreateMappedSuperclassFeature_createMappedSuperclassFeatureName;
51		53
52	public static String CreateManyToManyBiDirRelationFeature_manyToManyBiDirFeatureName;	54	public static String CreateManyToManyBiDirRelationFeature_manyToManyBiDirFeatureName;
53	public static String CreateManyToManyBiDirRelationFeature_manyToManyUniDirFeatureDescription;	55	public static String CreateManyToManyBiDirRelationFeature_manyToManyUniDirFeatureDescription;
Lines 181-187 Link Here
181	public static String JPAEditorToolBehaviorProvider_expandEntitymenuItemDescr;	183	public static String JPAEditorToolBehaviorProvider_expandEntitymenuItemDescr;
182		184
183	public static String JPAEditorToolBehaviorProvider_expandAllEntitiesMenuItem;	185	public static String JPAEditorToolBehaviorProvider_expandAllEntitiesMenuItem;
184	public static String JPAEditorToolBehaviorProvider_expandAllEntitiesMenuItemDescr;	186	public static String JPAEditorToolBehaviorProvider_expandAllEntitiesMenuItemDescr;
		187
		188	public static String JPAEditorToolBehaviorProvider_InheritanceCompartmentTitle;
185		189
186	public static String JPAEditorToolBehaviorProvider_refactorAttributeType;	190	public static String JPAEditorToolBehaviorProvider_refactorAttributeType;
187	public static String JPAEditorToolBehaviorProvider_refactorAttributeTypeDesc;	191	public static String JPAEditorToolBehaviorProvider_refactorAttributeTypeDesc;

Lines 25-30 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/i18n/messages.properties (+7 lines)
25		25
26	CreateDiagramJob_createDiagramJobName=Creating diagram for: {0}...	26	CreateDiagramJob_createDiagramJobName=Creating diagram for: {0}...
27	CreateDiagramJob_getJPADiagramMonitorTaskName=Get JPA Diagram	27	CreateDiagramJob_getJPADiagramMonitorTaskName=Get JPA Diagram
		28
		29	CreateIsARelationFeature_description=Click on an entity or mapped superclass and then click somewhere in the diagram to create new inherited entity
		30	CreateIsARelationFeature_name=Inherited Entity
		31
28	CreateJPAEntityFeature_createEntityErrorMsg=Entity could not be created.	32	CreateJPAEntityFeature_createEntityErrorMsg=Entity could not be created.
29	CreateJPAEntityFeature_createEntityErrorMsgTitle=Cannot Create Entity	33	CreateJPAEntityFeature_createEntityErrorMsgTitle=Cannot Create Entity
30	CreateJPAEntityFeature_createEntityErrorStatusMsg=Persistence API library is not into the project's classpath.	34	CreateJPAEntityFeature_createEntityErrorStatusMsg=Persistence API library is not into the project's classpath.
Lines 34-39 Link Here
34	CreateJPAEntityFeature_jpaProjectSelectionDialogTitle=Select JPA Project	38	CreateJPAEntityFeature_jpaProjectSelectionDialogTitle=Select JPA Project
35	CreateJPAEntityFromMappedSuperclassFeature_createInheritedEntityFeatureDescription=Create a new JPA entity that will inherit a new Mapped Superclass.	39	CreateJPAEntityFromMappedSuperclassFeature_createInheritedEntityFeatureDescription=Create a new JPA entity that will inherit a new Mapped Superclass.
36	CreateJPAEntityFromMappedSuperclassFeature_createInheritedEntityFeatureName=Inherited Entity	40	CreateJPAEntityFromMappedSuperclassFeature_createInheritedEntityFeatureName=Inherited Entity
		41	CreateMappedSuperclassFeature_createMappedSuperclassFeatureDescription=Create a new Mapped Superclass.
		42	CreateMappedSuperclassFeature_createMappedSuperclassFeatureName=Mapped Superclass
37		43
38	CreateManyToManyBiDirRelationFeature_manyToManyBiDirFeatureName=Many-to-Many	44	CreateManyToManyBiDirRelationFeature_manyToManyBiDirFeatureName=Many-to-Many
39	CreateManyToManyBiDirRelationFeature_manyToManyUniDirFeatureDescription=Create new bidirectional many-to-many relation.	45	CreateManyToManyBiDirRelationFeature_manyToManyUniDirFeatureDescription=Create new bidirectional many-to-many relation.
Lines 152-157 Link Here
152	JPAEditorToolBehaviorProvider_expandEntitymenuItemDescr=Expand entity.	158	JPAEditorToolBehaviorProvider_expandEntitymenuItemDescr=Expand entity.
153	JPAEditorToolBehaviorProvider_expandAllEntitiesMenuItem=Expand All	159	JPAEditorToolBehaviorProvider_expandAllEntitiesMenuItem=Expand All
154	JPAEditorToolBehaviorProvider_expandAllEntitiesMenuItemDescr=Expand all entities.	160	JPAEditorToolBehaviorProvider_expandAllEntitiesMenuItemDescr=Expand all entities.
		161	JPAEditorToolBehaviorProvider_InheritanceCompartmentTitle=Inheritance
155	JPAEditorToolBehaviorProvider_refactorAttributeType=Refactor Attribute Type...	162	JPAEditorToolBehaviorProvider_refactorAttributeType=Refactor Attribute Type...
156	JPAEditorToolBehaviorProvider_refactorAttributeTypeDesc=Change the type of the selected attribute.	163	JPAEditorToolBehaviorProvider_refactorAttributeTypeDesc=Change the type of the selected attribute.
157	JPAEditorToolBehaviorProvider_removeAllEntitiesMenu=Remove All Entities From Diagram	164	JPAEditorToolBehaviorProvider_removeAllEntitiesMenu=Remove All Entities From Diagram

Lines 178-184 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/modelintegration/ui/OpenJpaDiagramActionDelegate.java (-1 / +12 lines)
178	if (firstElement instanceof JpaNode) {	178	if (firstElement instanceof JpaNode) {
179	jpaProject = ((JpaNode)firstElement).getJpaProject();	179	jpaProject = ((JpaNode)firstElement).getJpaProject();
180	} else if (firstElement instanceof IProject) {	180	} else if (firstElement instanceof IProject) {
181	jpaProject = JpaArtifactFactory.instance().getJpaProject((IProject)firstElement);	181	int cnt = 0;
		182	while ((jpaProject == null) && (cnt < 25)) {
		183	jpaProject = JpaArtifactFactory.instance().getJpaProject((IProject)firstElement);
		184	if (jpaProject == null) {
		185	try {
		186	Thread.sleep(200);
		187	} catch (InterruptedException e) {
		188	JPADiagramEditorPlugin.logError("Thread sleep interrupted", e); //$NON-NLS-1$
		189	}
		190	}
		191	cnt++;
		192	}
182	}	193	}
183	return JpaArtifactFactory.instance().getPersistenceUnit(jpaProject);	194	return JpaArtifactFactory.instance().getPersistenceUnit(jpaProject);
184	}	195	}

Lines 18-59 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/JPAEditorImageProvider.java (-55 / +60 lines)
18	import org.eclipse.graphiti.ui.platform.AbstractImageProvider;	18	import org.eclipse.graphiti.ui.platform.AbstractImageProvider;
19		19
20	public class JPAEditorImageProvider extends AbstractImageProvider {	20	public class JPAEditorImageProvider extends AbstractImageProvider {
21		21
22	public final static String ID = "org.eclipse.jpt.jpadiagrameditor.ui.JPAEditorImageProvider"; //$NON-NLS-1$	22	private final static String PREFIX = "org.eclipse.jpt.jpadiagrameditor.ui."; //$NON-NLS-1$
23	static final String PRE = "org.eclipse.jpt.jpadiagrameditor.ui."; //$NON-NLS-1$	23	public final static String ID = "org.eclipse.jpt.jpadiagrameditor.ui.JPAEditorImageProvider"; //$NON-NLS-1$
24	public static final String JPA_ENTITY = PRE + "entity"; //$NON-NLS-1$	24
25	public static final String ADD_JPA_ENTITY = PRE + "add_entity"; //$NON-NLS-1$	25	public static final String JPA_ENTITY = PREFIX + "entity"; //$NON-NLS-1$
26	public static final String ADD_INHERITED_ENTITY = PRE + "mapped_superclass"; //$NON-NLS-1$	26	public static final String MAPPED_SUPERCLASS = PREFIX + "mapped_superclass"; //$NON-NLS-1$
27	public static final String PRIMARY_KEY = PRE + "pk"; //$NON-NLS-1$	27	public static final String ADD_JPA_ENTITY = PREFIX + "add_entity"; //$NON-NLS-1$
28	public static final String ICON_BASIC = PRE + "field"; //$NON-NLS-1$	28	public static final String ADD_INHERITED_ENTITY = PREFIX + "add_inherited_entity"; //$NON-NLS-1$
29	public static final String ADD_ATTRIBUTE = PRE + "add_attribute"; //$NON-NLS-1$	29	public static final String ADD_MAPPED_SUPERCLASS = PREFIX + "add_mapped_superclass"; //$NON-NLS-1$
30	public static final String REMOVE_ATTRIBUTE = PRE + "remove_attribute"; //$NON-NLS-1$	30	public static final String PRIMARY_KEY = PREFIX + "pk"; //$NON-NLS-1$
31	public static final String ICON_ONE_TO_ONE = PRE + "one_to_one_relation"; //$NON-NLS-1$	31	public static final String ICON_BASIC = PREFIX + "field"; //$NON-NLS-1$
32	public static final String ICON_ONE_TO_MANY = PRE + "one_to_many_relation"; //$NON-NLS-1$	32	public static final String ADD_ATTRIBUTE = PREFIX + "add_attribute"; //$NON-NLS-1$
33	public static final String ICON_MANY_TO_ONE = PRE + "many_to_one_relation"; //$NON-NLS-1$	33	public static final String REMOVE_ATTRIBUTE = PREFIX + "remove_attribute"; //$NON-NLS-1$
34	public static final String ICON_MANY_TO_MANY = PRE + "many_to_many_relation"; //$NON-NLS-1$	34	public static final String ICON_ONE_TO_ONE = PREFIX + "one_to_one_relation"; //$NON-NLS-1$
35	public static final String ICON_EMBEDDED_ID = PRE + "embedded_id"; //$NON-NLS-1$	35	public static final String ICON_ONE_TO_MANY = PREFIX + "one_to_many_relation"; //$NON-NLS-1$
36	public static final String ICON_VERSION = PRE + "version"; //$NON-NLS-1$	36	public static final String ICON_MANY_TO_ONE = PREFIX + "many_to_one_relation"; //$NON-NLS-1$
37	public static final String ICON_TRANSIENT = PRE + "transient"; //$NON-NLS-1$	37	public static final String ICON_MANY_TO_MANY = PREFIX + "many_to_many_relation"; //$NON-NLS-1$
38	public static final String ICON_EMBEDDED = PRE + "embedded"; //$NON-NLS-1$	38	public static final String ICON_EMBEDDED_ID = PREFIX + "embedded_id"; //$NON-NLS-1$
39	public static final String ICON_UNMAPPED = PRE + "unmapped"; //$NON-NLS-1$	39	public static final String ICON_VERSION = PREFIX + "version"; //$NON-NLS-1$
40		40	public static final String ICON_TRANSIENT = PREFIX + "transient"; //$NON-NLS-1$
41		41	public static final String ICON_EMBEDDED = PREFIX + "embedded"; //$NON-NLS-1$
42	public static final String ICON_ONE_TO_ONE_1_DIR = PRE + "one_to_one_1_dir_relation"; //$NON-NLS-1$	42	public static final String ICON_UNMAPPED = PREFIX + "unmapped"; //$NON-NLS-1$
43	public static final String ICON_ONE_TO_MANY_1_DIR = PRE + "one_to_many_1_dir_relation"; //$NON-NLS-1$	43
44	public static final String ICON_MANY_TO_ONE_1_DIR = PRE + "many_to_one_1_dir_relation"; //$NON-NLS-1$	44
45	public static final String ICON_MANY_TO_MANY_1_DIR = PRE + "many_to_many_1_dir_relation"; //$NON-NLS-1$	45	public static final String ICON_ONE_TO_ONE_1_DIR = PREFIX + "one_to_one_1_dir_relation"; //$NON-NLS-1$
46		46	public static final String ICON_ONE_TO_MANY_1_DIR = PREFIX + "one_to_many_1_dir_relation"; //$NON-NLS-1$
47	public static final String ICON_ONE_TO_ONE_2_DIR = PRE + "one_to_one_2_dir_relation"; //$NON-NLS-1$	47	public static final String ICON_MANY_TO_ONE_1_DIR = PREFIX + "many_to_one_1_dir_relation"; //$NON-NLS-1$
48	public static final String ICON_MANY_TO_ONE_2_DIR = PRE + "many_to_one_2_dir_relation"; //$NON-NLS-1$	48	public static final String ICON_MANY_TO_MANY_1_DIR = PREFIX + "many_to_many_1_dir_relation"; //$NON-NLS-1$
49	public static final String ICON_MANY_TO_MANY_2_DIR = PRE + "many_to_many_2_dir_relation"; //$NON-NLS-1$	49
		50	public static final String ICON_ONE_TO_ONE_2_DIR = PREFIX + "one_to_one_2_dir_relation"; //$NON-NLS-1$
		51	public static final String ICON_MANY_TO_ONE_2_DIR = PREFIX + "many_to_one_2_dir_relation"; //$NON-NLS-1$
		52	public static final String ICON_MANY_TO_MANY_2_DIR = PREFIX + "many_to_many_2_dir_relation"; //$NON-NLS-1$
50		53
51		54
52	public static final String ICON_SAVE = PRE + "save"; //$NON-NLS-1$	55	public static final String ICON_SAVE = PREFIX + "save"; //$NON-NLS-1$
53	public static final String ICON_RESTORE = PRE + "restore"; //$NON-NLS-1$	56	public static final String ICON_RESTORE = PREFIX + "restore"; //$NON-NLS-1$
54	public static final String ICON_SAVE_AND_REMOVE = PRE + "save_and_remove"; //$NON-NLS-1$	57	public static final String ICON_SAVE_AND_REMOVE = PREFIX + "save_and_remove"; //$NON-NLS-1$
55		58
56	private static final String ROOT_FOLDER_FOR_IMG = "icons/"; //$NON-NLS-1$	59	private static final String ROOT_FOLDER_FOR_IMG = "icons/"; //$NON-NLS-1$
57		60
58	public JPAEditorImageProvider() {	61	public JPAEditorImageProvider() {
59	super();	62	super();
Lines 62-95 Link Here
62	@Override	65	@Override
63	protected void addAvailableImages() {	66	protected void addAvailableImages() {
64	addImageFilePath(ICON_BASIC, ROOT_FOLDER_FOR_IMG + "ent/basic.gif"); //$NON-NLS-1$	67	addImageFilePath(ICON_BASIC, ROOT_FOLDER_FOR_IMG + "ent/basic.gif"); //$NON-NLS-1$
65	addImageFilePath(JPA_ENTITY, ROOT_FOLDER_FOR_IMG + "ent/entity.gif"); //$NON-NLS-1$	68	addImageFilePath(JPA_ENTITY, ROOT_FOLDER_FOR_IMG + "ent/entity.gif"); //$NON-NLS-1$
		69	addImageFilePath(MAPPED_SUPERCLASS, ROOT_FOLDER_FOR_IMG + "ent/mapped-superclass.gif"); //$NON-NLS-1$
66	addImageFilePath(ADD_JPA_ENTITY, ROOT_FOLDER_FOR_IMG + "ent/add_entity.gif"); //$NON-NLS-1$	70	addImageFilePath(ADD_JPA_ENTITY, ROOT_FOLDER_FOR_IMG + "ent/add_entity.gif"); //$NON-NLS-1$
67	addImageFilePath(ADD_INHERITED_ENTITY, ROOT_FOLDER_FOR_IMG + "ent/mapped-superclass.gif"); //$NON-NLS-1$	71	addImageFilePath(ADD_INHERITED_ENTITY, ROOT_FOLDER_FOR_IMG + "ent/add_entity.gif"); //$NON-NLS-1$
68	addImageFilePath(PRIMARY_KEY, ROOT_FOLDER_FOR_IMG + "ent/id.gif"); //$NON-NLS-1$	72	addImageFilePath(ADD_MAPPED_SUPERCLASS, ROOT_FOLDER_FOR_IMG + "ent/add_mapped-superclass.gif"); //$NON-NLS-1$
69	addImageFilePath(ADD_ATTRIBUTE, ROOT_FOLDER_FOR_IMG + "ent/add_attribute.gif"); //$NON-NLS-1$	73	addImageFilePath(PRIMARY_KEY, ROOT_FOLDER_FOR_IMG + "ent/id.gif"); //$NON-NLS-1$
70	addImageFilePath(REMOVE_ATTRIBUTE, ROOT_FOLDER_FOR_IMG + "ent/remove_attribute.gif"); //$NON-NLS-1$	74	addImageFilePath(ADD_ATTRIBUTE, ROOT_FOLDER_FOR_IMG + "ent/add_attribute.gif"); //$NON-NLS-1$
71	addImageFilePath(ICON_ONE_TO_ONE, ROOT_FOLDER_FOR_IMG + "ent/one-to-one.gif"); //$NON-NLS-1$	75	addImageFilePath(REMOVE_ATTRIBUTE, ROOT_FOLDER_FOR_IMG + "ent/remove_attribute.gif"); //$NON-NLS-1$
72	addImageFilePath(ICON_ONE_TO_MANY, ROOT_FOLDER_FOR_IMG + "ent/one-to-many.gif"); //$NON-NLS-1$	76	addImageFilePath(ICON_ONE_TO_ONE, ROOT_FOLDER_FOR_IMG + "ent/one-to-one.gif"); //$NON-NLS-1$
73	addImageFilePath(ICON_MANY_TO_ONE, ROOT_FOLDER_FOR_IMG + "ent/many-to-one.gif"); //$NON-NLS-1$	77	addImageFilePath(ICON_ONE_TO_MANY, ROOT_FOLDER_FOR_IMG + "ent/one-to-many.gif"); //$NON-NLS-1$
74	addImageFilePath(ICON_MANY_TO_MANY, ROOT_FOLDER_FOR_IMG + "ent/many-to-many.gif"); //$NON-NLS-1$	78	addImageFilePath(ICON_MANY_TO_ONE, ROOT_FOLDER_FOR_IMG + "ent/many-to-one.gif"); //$NON-NLS-1$
75	addImageFilePath(ICON_EMBEDDED_ID, ROOT_FOLDER_FOR_IMG + "ent/embedded-id.gif"); //$NON-NLS-1$	79	addImageFilePath(ICON_MANY_TO_MANY, ROOT_FOLDER_FOR_IMG + "ent/many-to-many.gif"); //$NON-NLS-1$
76	addImageFilePath(ICON_VERSION, ROOT_FOLDER_FOR_IMG + "ent/version.gif"); //$NON-NLS-1$	80	addImageFilePath(ICON_EMBEDDED_ID, ROOT_FOLDER_FOR_IMG + "ent/embedded-id.gif"); //$NON-NLS-1$
77	addImageFilePath(ICON_TRANSIENT, ROOT_FOLDER_FOR_IMG + "ent/transient.gif"); //$NON-NLS-1$	81	addImageFilePath(ICON_VERSION, ROOT_FOLDER_FOR_IMG + "ent/version.gif"); //$NON-NLS-1$
78	addImageFilePath(ICON_EMBEDDED, ROOT_FOLDER_FOR_IMG + "ent/embedded.gif"); //$NON-NLS-1$	82	addImageFilePath(ICON_TRANSIENT, ROOT_FOLDER_FOR_IMG + "ent/transient.gif"); //$NON-NLS-1$
79	addImageFilePath(ICON_UNMAPPED, ROOT_FOLDER_FOR_IMG + "ent/null-attribute-mapping.gif"); //$NON-NLS-1$	83	addImageFilePath(ICON_EMBEDDED, ROOT_FOLDER_FOR_IMG + "ent/embedded.gif"); //$NON-NLS-1$
		84	addImageFilePath(ICON_UNMAPPED, ROOT_FOLDER_FOR_IMG + "ent/null-attribute-mapping.gif"); //$NON-NLS-1$
80		85
81	addImageFilePath(ICON_ONE_TO_ONE_1_DIR, ROOT_FOLDER_FOR_IMG + "ent/one-to-one-1-dir.gif"); //$NON-NLS-1$	86	addImageFilePath(ICON_ONE_TO_ONE_1_DIR, ROOT_FOLDER_FOR_IMG + "ent/one-to-one-1-dir.gif"); //$NON-NLS-1$
82	addImageFilePath(ICON_ONE_TO_MANY_1_DIR, ROOT_FOLDER_FOR_IMG + "ent/one-to-many-1-dir.gif"); //$NON-NLS-1$	87	addImageFilePath(ICON_ONE_TO_MANY_1_DIR, ROOT_FOLDER_FOR_IMG + "ent/one-to-many-1-dir.gif"); //$NON-NLS-1$
83	addImageFilePath(ICON_MANY_TO_ONE_1_DIR, ROOT_FOLDER_FOR_IMG + "ent/many-to-one-1-dir.gif"); //$NON-NLS-1$	88	addImageFilePath(ICON_MANY_TO_ONE_1_DIR, ROOT_FOLDER_FOR_IMG + "ent/many-to-one-1-dir.gif"); //$NON-NLS-1$
84	addImageFilePath(ICON_MANY_TO_MANY_1_DIR, ROOT_FOLDER_FOR_IMG + "ent/many-to-many-1-dir.gif"); //$NON-NLS-1$	89	addImageFilePath(ICON_MANY_TO_MANY_1_DIR, ROOT_FOLDER_FOR_IMG + "ent/many-to-many-1-dir.gif"); //$NON-NLS-1$
85		90
86	addImageFilePath(ICON_ONE_TO_ONE_2_DIR, ROOT_FOLDER_FOR_IMG + "ent/one-to-one-2-dir.gif"); //$NON-NLS-1$	91	addImageFilePath(ICON_ONE_TO_ONE_2_DIR, ROOT_FOLDER_FOR_IMG + "ent/one-to-one-2-dir.gif"); //$NON-NLS-1$
87	addImageFilePath(ICON_MANY_TO_ONE_2_DIR, ROOT_FOLDER_FOR_IMG + "ent/many-to-one-2-dir.gif"); //$NON-NLS-1$	92	addImageFilePath(ICON_MANY_TO_ONE_2_DIR, ROOT_FOLDER_FOR_IMG + "ent/many-to-one-2-dir.gif"); //$NON-NLS-1$
88	addImageFilePath(ICON_MANY_TO_MANY_2_DIR, ROOT_FOLDER_FOR_IMG + "ent/many-to-many-2-dir.gif"); //$NON-NLS-1$	93	addImageFilePath(ICON_MANY_TO_MANY_2_DIR, ROOT_FOLDER_FOR_IMG + "ent/many-to-many-2-dir.gif"); //$NON-NLS-1$
89		94
90	addImageFilePath(ICON_SAVE, ROOT_FOLDER_FOR_IMG + "save.gif"); //$NON-NLS-1$	95	addImageFilePath(ICON_SAVE, ROOT_FOLDER_FOR_IMG + "save.gif"); //$NON-NLS-1$
91	addImageFilePath(ICON_RESTORE, ROOT_FOLDER_FOR_IMG + "restore.gif"); //$NON-NLS-1$	96	addImageFilePath(ICON_RESTORE, ROOT_FOLDER_FOR_IMG + "restore.gif"); //$NON-NLS-1$
92	addImageFilePath(ICON_SAVE_AND_REMOVE, ROOT_FOLDER_FOR_IMG + "save_and_remove.gif"); //$NON-NLS-1$	97	addImageFilePath(ICON_SAVE_AND_REMOVE, ROOT_FOLDER_FOR_IMG + "save_and_remove.gif"); //$NON-NLS-1$
93	}	98	}
94		99
95	}	100	}

Lines 20-29 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/EntityChangeListener.java (-19 / +3 lines)
20	import java.util.Hashtable;	20	import java.util.Hashtable;
21	import java.util.Iterator;	21	import java.util.Iterator;
22	import java.util.Set;	22	import java.util.Set;
		23
23	import org.eclipse.graphiti.features.context.impl.RemoveContext;	24	import org.eclipse.graphiti.features.context.impl.RemoveContext;
24	import org.eclipse.graphiti.mm.pictograms.ContainerShape;	25	import org.eclipse.graphiti.mm.pictograms.ContainerShape;
25	import org.eclipse.jdt.core.ICompilationUnit;
26	import org.eclipse.jdt.core.JavaModelException;
27	import org.eclipse.jpt.common.core.resource.java.Annotation;	26	import org.eclipse.jpt.common.core.resource.java.Annotation;
28	import org.eclipse.jpt.jpa.core.JptJpaCorePlugin;	27	import org.eclipse.jpt.jpa.core.JptJpaCorePlugin;
29	import org.eclipse.jpt.jpa.core.context.MappedByRelationship;	28	import org.eclipse.jpt.jpa.core.context.MappedByRelationship;
Lines 122-128 Link Here
122	PersistenceUnit pu = JpaArtifactFactory.instance().getPersistenceUnit(jpt);	121	PersistenceUnit pu = JpaArtifactFactory.instance().getPersistenceUnit(jpt);
123	PersistentType pt = pu.getPersistentType(jpt.getName());	122	PersistentType pt = pu.getPersistentType(jpt.getName());
124		123
125	if ((pt == null) \|\| !JpaArtifactFactory.instance().hasEntityAnnotation(jpt)) {	124	if ((pt == null) \|\| !JpaArtifactFactory.instance().hasEntityOrMappedSuperclassAnnotation(jpt)) {
126		125
127	JpaArtifactFactory.instance().forceSaveEntityClass(jpt, featureProvider);	126	JpaArtifactFactory.instance().forceSaveEntityClass(jpt, featureProvider);
128		127
Lines 136-156 Link Here
136	RemoveAndSaveEntityFeature ft = new RemoveAndSaveEntityFeature(featureProvider);	135	RemoveAndSaveEntityFeature ft = new RemoveAndSaveEntityFeature(featureProvider);
137	ft.remove(ctx);	136	ft.remove(ctx);
138	break;	137	break;
139	} else {
140
141	ICompilationUnit cu = featureProvider.getCompilationUnit(jpt);
142	String entName = JPAEditorUtil.returnSimpleName(JpaArtifactFactory.instance().getEntityName(jpt));
143	try {
144	final String newHeader = (cu.hasUnsavedChanges() ? "* " : "") + entName; //$NON-NLS-1$ //$NON-NLS-2$
145	Display.getDefault().asyncExec(new Runnable() {
146	public void run() {
147	GraphicsUpdater.updateHeader(entShape, newHeader);
148	}
149	});
150
151	} catch (JavaModelException e) {
152	JPADiagramEditorPlugin.logError("Cannot check compilation unit for unsaved changes", e); //$NON-NLS-1$
153	}
154	}	138	}
155	}	139	}
156	}	140	}
Lines 192-198 Link Here
192	}	176	}
193	}	177	}
194	} catch(Exception e) {	178	} catch(Exception e) {
195	//$NON-NLS-1$	179	//ignore
196	}	180	}
197	}	181	}
198	}	182	}

Lines 166-174 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/GraphicsUpdater.java (-14 / +24 lines)
166	}	166	}
167		167
168	public static void updateHeader(ContainerShape entityShape, final String newHeader) {	168	public static void updateHeader(ContainerShape entityShape, final String newHeader) {
169	if(entityShape == null)	169	final Text txt = getHeaderText(entityShape);
		170	if (txt == null)
170	return;	171	return;
171		172	//if (!JPAEditorUtil.areHeadersEqual(txt.getValue(), newHeader)) {
		173
		174	if (!txt.getValue().equals(newHeader)) {
		175	TransactionalEditingDomain ted = TransactionUtil.getEditingDomain(txt);
		176	RecordingCommand rc = new RecordingCommand(ted) {
		177	protected void doExecute() {
		178	txt.setValue(newHeader);
		179	}
		180	};
		181	ted.getCommandStack().execute(rc);
		182	}
		183	}
		184
		185	private static Text getHeaderText(ContainerShape entityShape) {
		186	if(entityShape == null)
		187	return null;
172	List<Shape> shapes = entityShape.getChildren();	188	List<Shape> shapes = entityShape.getChildren();
173	Iterator<Shape> shIt = shapes.iterator();	189	Iterator<Shape> shIt = shapes.iterator();
174	Shape headerShape = null;;	190	Shape headerShape = null;;
Lines 180-198 Link Here
180	headerShape = null;	196	headerShape = null;
181	}	197	}
182	if (headerShape == null)	198	if (headerShape == null)
183	return;	199	return null;
184	GraphicsAlgorithm ga = headerShape.getGraphicsAlgorithm();	200	GraphicsAlgorithm ga = headerShape.getGraphicsAlgorithm();
185	if (ga == null)	201	if (ga == null)
186	return;	202	return null;
187	final Text txt = (Text)ga.getGraphicsAlgorithmChildren().get(0);	203	if (ga.getGraphicsAlgorithmChildren().size() == 0)
188	if (!JPAEditorUtil.areHeadersEqual(txt.getValue(), newHeader)) {	204	return null;
189	TransactionalEditingDomain ted = TransactionUtil.getEditingDomain(txt);	205	Text txt = (Text)ga.getGraphicsAlgorithmChildren().get(0);
190	RecordingCommand rc = new RecordingCommand(ted) {	206	return txt;
191	protected void doExecute() {
192	txt.setValue(newHeader);
193	}
194	};
195	ted.getCommandStack().execute(rc);
196	}
197	}	207	}
198	}	208	}

Lines 27-36 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JpaArtifactFactory.java (-19 / +186 lines)
27	import java.util.Locale;	27	import java.util.Locale;
28	import java.util.Properties;	28	import java.util.Properties;
29	import java.util.Set;	29	import java.util.Set;
		30
30	import org.eclipse.core.resources.IProject;	31	import org.eclipse.core.resources.IProject;
31	import org.eclipse.core.resources.IResource;	32	import org.eclipse.core.resources.IResource;
32	import org.eclipse.core.runtime.CoreException;	33	import org.eclipse.core.runtime.CoreException;
33	import org.eclipse.core.runtime.NullProgressMonitor;	34	import org.eclipse.core.runtime.NullProgressMonitor;
		35	import org.eclipse.emf.transaction.RecordingCommand;
		36	import org.eclipse.emf.transaction.TransactionalEditingDomain;
34	import org.eclipse.graphiti.features.IFeatureProvider;	37	import org.eclipse.graphiti.features.IFeatureProvider;
35	import org.eclipse.graphiti.features.context.IRemoveContext;	38	import org.eclipse.graphiti.features.context.IRemoveContext;
36	import org.eclipse.graphiti.features.context.impl.AddConnectionContext;	39	import org.eclipse.graphiti.features.context.impl.AddConnectionContext;
Lines 39-48 Link Here
39	import org.eclipse.graphiti.mm.pictograms.ContainerShape;	42	import org.eclipse.graphiti.mm.pictograms.ContainerShape;
40	import org.eclipse.graphiti.mm.pictograms.Shape;	43	import org.eclipse.graphiti.mm.pictograms.Shape;
41	import org.eclipse.graphiti.services.Graphiti;	44	import org.eclipse.graphiti.services.Graphiti;
		45	import org.eclipse.graphiti.util.IColorConstant;
42	import org.eclipse.jdt.core.ICompilationUnit;	46	import org.eclipse.jdt.core.ICompilationUnit;
43	import org.eclipse.jdt.core.IField;	47	import org.eclipse.jdt.core.IField;
44	import org.eclipse.jdt.core.IImportDeclaration;	48	import org.eclipse.jdt.core.IImportDeclaration;
45	import org.eclipse.jdt.core.IMethod;	49	import org.eclipse.jdt.core.IMethod;
		50	import org.eclipse.jdt.core.IPackageDeclaration;
46	import org.eclipse.jdt.core.IType;	51	import org.eclipse.jdt.core.IType;
47	import org.eclipse.jdt.core.JavaModelException;	52	import org.eclipse.jdt.core.JavaModelException;
48	import org.eclipse.jdt.core.dom.CompilationUnit;	53	import org.eclipse.jdt.core.dom.CompilationUnit;
Lines 68-73 Link Here
68	import org.eclipse.jpt.jpa.core.context.java.JavaAttributeMapping;	73	import org.eclipse.jpt.jpa.core.context.java.JavaAttributeMapping;
69	import org.eclipse.jpt.jpa.core.context.java.JavaEntity;	74	import org.eclipse.jpt.jpa.core.context.java.JavaEntity;
70	import org.eclipse.jpt.jpa.core.context.java.JavaManyToManyMapping;	75	import org.eclipse.jpt.jpa.core.context.java.JavaManyToManyMapping;
		76	import org.eclipse.jpt.jpa.core.context.java.JavaMappedSuperclass;
71	import org.eclipse.jpt.jpa.core.context.java.JavaOneToManyMapping;	77	import org.eclipse.jpt.jpa.core.context.java.JavaOneToManyMapping;
72	import org.eclipse.jpt.jpa.core.context.java.JavaOneToOneMapping;	78	import org.eclipse.jpt.jpa.core.context.java.JavaOneToOneMapping;
73	import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;	79	import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
Lines 77-84 Link Here
77	import org.eclipse.jpt.jpa.core.context.persistence.PersistenceUnit;	83	import org.eclipse.jpt.jpa.core.context.persistence.PersistenceUnit;
78	import org.eclipse.jpt.jpa.core.resource.java.AttributeOverrideAnnotation;	84	import org.eclipse.jpt.jpa.core.resource.java.AttributeOverrideAnnotation;
79	import org.eclipse.jpt.jpa.core.resource.java.ColumnAnnotation;	85	import org.eclipse.jpt.jpa.core.resource.java.ColumnAnnotation;
80	import org.eclipse.jpt.jpa.core.resource.java.EmbeddedIdAnnotation;
81	import org.eclipse.jpt.jpa.core.resource.java.IdAnnotation;
82	import org.eclipse.jpt.jpa.core.resource.java.IdClassAnnotation;	86	import org.eclipse.jpt.jpa.core.resource.java.IdClassAnnotation;
83	import org.eclipse.jpt.jpa.core.resource.java.JoinColumnAnnotation;	87	import org.eclipse.jpt.jpa.core.resource.java.JoinColumnAnnotation;
84	import org.eclipse.jpt.jpa.core.resource.java.ManyToManyAnnotation;	88	import org.eclipse.jpt.jpa.core.resource.java.ManyToManyAnnotation;
Lines 89-104 Link Here
89	import org.eclipse.jpt.jpa.core.resource.java.RelationshipMappingAnnotation;	93	import org.eclipse.jpt.jpa.core.resource.java.RelationshipMappingAnnotation;
90	import org.eclipse.jpt.jpa.core.resource.java.TableAnnotation;	94	import org.eclipse.jpt.jpa.core.resource.java.TableAnnotation;
91	import org.eclipse.jpt.jpadiagrameditor.ui.internal.JPADiagramEditorPlugin;	95	import org.eclipse.jpt.jpadiagrameditor.ui.internal.JPADiagramEditorPlugin;
		96	import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.AddInheritedEntityFeature;
92	import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.AddRelationFeature;	97	import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.AddRelationFeature;
93	import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.RemoveRelationFeature;	98	import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.RemoveRelationFeature;
94	import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.UpdateAttributeFeature;	99	import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.UpdateAttributeFeature;
95	import org.eclipse.jpt.jpadiagrameditor.ui.internal.i18n.JPAEditorMessages;	100	import org.eclipse.jpt.jpadiagrameditor.ui.internal.i18n.JPAEditorMessages;
96	import org.eclipse.jpt.jpadiagrameditor.ui.internal.propertypage.JPADiagramPropertyPage;	101	import org.eclipse.jpt.jpadiagrameditor.ui.internal.propertypage.JPADiagramPropertyPage;
97	import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;	102	import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;
98	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.BidirectionalRelation;	103	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IBidirectionalRelation;
99	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation;	104	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation;
100	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation.RelDir;	105	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation.RelDir;
101	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation.RelType;	106	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation.RelType;
		107	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IsARelation;
102	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.ManyToManyBiDirRelation;	108	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.ManyToManyBiDirRelation;
103	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.ManyToManyUniDirRelation;	109	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.ManyToManyUniDirRelation;
104	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.ManyToOneBiDirRelation;	110	import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.ManyToOneBiDirRelation;
Lines 129-134 Link Here
129	return INSTANCE;	135	return INSTANCE;
130	}	136	}
131		137
		138	public void rearrangeIsARelations(IJPAEditorFeatureProvider fp) {
		139	Collection<IsARelation> isARels = produceAllMissingIsARelations(fp);
		140	addIsARelations(fp, isARels);
		141	fp.removeAllRedundantIsARelations();
		142	}
		143
		144	public void rearrangeIsARelationsInTransaction(final IJPAEditorFeatureProvider fp) {
		145	final Collection<IsARelation> isARels = produceAllMissingIsARelations(fp);
		146	if (!fp.existRedundantIsARelations() && (isARels.size() == 0))
		147	return;
		148	TransactionalEditingDomain ted = fp.getTransactionalEditingDomain();
		149	RecordingCommand rc = new RecordingCommand(ted) {
		150	protected void doExecute() {
		151	addIsARelations(fp, isARels);
		152	fp.removeAllRedundantIsARelations();
		153	}
		154	};
		155	ted.getCommandStack().execute(rc);
		156	}
		157
		158
		159	public Collection<IsARelation> produceAllMissingIsARelations(IJPAEditorFeatureProvider fp) {
		160	Collection<JavaPersistentType> persistentTypes = fp.getPersistentTypes();
		161	Collection<IsARelation> res = new HashSet<IsARelation>();
		162	Iterator<JavaPersistentType> it = persistentTypes.iterator();
		163	HashSet<IsARelation> allExistingIsARelations = fp.getAllExistingIsARelations();
		164	while (it.hasNext()) {
		165	JavaPersistentType jpt = it.next();
		166	JavaPersistentType superclass = fp.getFirstSuperclassBelongingToTheDiagram(jpt);
		167	if (superclass == null)
		168	continue;
		169	IsARelation newRel = new IsARelation(jpt, superclass);
		170	if (!allExistingIsARelations.contains(newRel))
		171	res.add(newRel);
		172	}
		173	return res;
		174	}
		175
132	public void addOneToOneUnidirectionalRelation(IFeatureProvider fp, JavaPersistentType jpt,	176	public void addOneToOneUnidirectionalRelation(IFeatureProvider fp, JavaPersistentType jpt,
133	JavaPersistentAttribute attribute) {	177	JavaPersistentAttribute attribute) {
134	addOneToOneRelation(fp, jpt, attribute, null, null,	178	addOneToOneRelation(fp, jpt, attribute, null, null,
Lines 445-451 Link Here
445	IJPAEditorFeatureProvider fp) {	489	IJPAEditorFeatureProvider fp) {
446	ICompilationUnit cu = fp.getCompilationUnit(jpt);	490	ICompilationUnit cu = fp.getCompilationUnit(jpt);
447	try {	491	try {
448	JpaProject jpaProject = jpt.getJpaProject();
449	JPAEditorUtil.discardWorkingCopy(cu);	492	JPAEditorUtil.discardWorkingCopy(cu);
450	cu.delete(true, new NullProgressMonitor());	493	cu.delete(true, new NullProgressMonitor());
451	return true;	494	return true;
Lines 514-522 Link Here
514	JavaResourceType jrpt = convertJPTToJRT(jpt);	557	JavaResourceType jrpt = convertJPTToJRT(jpt);
515	if (jrpt == null)	558	if (jrpt == null)
516	return false;	559	return false;
517	JavaEntity mapping = (JavaEntity) jpt.getMapping();	560	JavaTypeMapping jtm = jpt.getMapping();
518	if (mapping != null)	561	if (jtm == null)
		562	return false;
		563	if (jtm instanceof JavaEntity) {
		564	JavaEntity mapping = (JavaEntity)jtm;
519	return (mapping.getSpecifiedName() != null);	565	return (mapping.getSpecifiedName() != null);
		566	}
520	return false;	567	return false;
521	}	568	}
522		569
Lines 551-569 Link Here
551	}	598	}
552	*/	599	*/
553		600
		601	public boolean hasEntityOrMappedSuperclassAnnotation(JavaPersistentType jpt) {
		602	return hasEntityAnnotation(jpt) \|\| hasMappedSuperclassAnnotation(jpt);
		603	}
		604
554	public boolean hasEntityAnnotation(JavaPersistentType jpt) {	605	public boolean hasEntityAnnotation(JavaPersistentType jpt) {
555	return (jpt.getMapping() instanceof JavaEntity);	606	return (jpt.getMappingKey() == MappingKeys.ENTITY_TYPE_MAPPING_KEY);
556	}	607	}
557		608
		609	public boolean hasMappedSuperclassAnnotation(JavaPersistentType jpt) {
		610	return (jpt.getMappingKey() == MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY);
		611	}
		612
558	public String getSpecifiedEntityName(JavaPersistentType jpt){	613	public String getSpecifiedEntityName(JavaPersistentType jpt){
559	JavaEntity gje = (JavaEntity) jpt.getMapping();	614	JavaTypeMapping jtm = jpt.getMapping();
		615	if (jtm instanceof JavaEntity) {
		616	JavaEntity gje = (JavaEntity)jtm;
560	return gje.getSpecifiedName();	617	return gje.getSpecifiedName();
561	}	618	}
		619	JavaMappedSuperclass jms = (JavaMappedSuperclass)jtm;
		620	return jms.getName();
		621	}
562		622
563	public void renameEntity(JavaPersistentType jpt, String newName) {	623	public void renameEntity(JavaPersistentType jpt, String newName) {
564	JavaEntity gje = (JavaEntity)jpt.getMapping();	624	JavaTypeMapping jtm = jpt.getMapping();
		625	if (jtm instanceof JavaEntity) {
		626	JavaEntity gje = (JavaEntity)jtm;
565	gje.setSpecifiedName(newName);	627	gje.setSpecifiedName(newName);
566	}	628	}
		629	}
567		630
568	public JavaPersistentAttribute addAttribute(IJPAEditorFeatureProvider fp, JavaPersistentType jpt,	631	public JavaPersistentAttribute addAttribute(IJPAEditorFeatureProvider fp, JavaPersistentType jpt,
569	JavaPersistentType attributeType, String attributeName,	632	JavaPersistentType attributeType, String attributeName,
Lines 1478-1484 Link Here
1478	IRelation rel = fp.getRelationRelatedToAttribute(oldAt);	1541	IRelation rel = fp.getRelationRelatedToAttribute(oldAt);
1479	String inverseJPAName = null;	1542	String inverseJPAName = null;
1480	JavaPersistentType inverseJPT = null;	1543	JavaPersistentType inverseJPT = null;
1481	if (BidirectionalRelation.class.isInstance(rel)) {	1544	if (IBidirectionalRelation.class.isInstance(rel)) {
1482	inverseJPT = rel.getInverse();	1545	inverseJPT = rel.getInverse();
1483	if (inverseJPT != oldAt.getParent()) {	1546	if (inverseJPT != oldAt.getParent()) {
1484	pu = JpaArtifactFactory.INSTANCE.getPersistenceUnit(jpt);	1547	pu = JpaArtifactFactory.INSTANCE.getPersistenceUnit(jpt);
Lines 1832-1838 Link Here
1832	return res;	1895	return res;
1833	}	1896	}
1834		1897
1835	private BidirectionalRelation produceBiDirRelation(JavaPersistentType jpt,	1898	private IBidirectionalRelation produceBiDirRelation(JavaPersistentType jpt,
1836	JavaPersistentAttribute at, Annotation an,	1899	JavaPersistentAttribute at, Annotation an,
1837	JavaPersistentType relJPT, JavaPersistentAttribute relAt,	1900	JavaPersistentType relJPT, JavaPersistentAttribute relAt,
1838	Annotation relAn, IJPAEditorFeatureProvider fp) {	1901	Annotation relAn, IJPAEditorFeatureProvider fp) {
Lines 1876-1882 Link Here
1876	}	1939	}
1877	}	1940	}
1878		1941
1879	BidirectionalRelation res = null;	1942	IBidirectionalRelation res = null;
1880	if (annotationName.equals(JPAEditorConstants.ANNOTATION_ONE_TO_ONE)) {	1943	if (annotationName.equals(JPAEditorConstants.ANNOTATION_ONE_TO_ONE)) {
1881	if (!fp.doesRelationExist(jpt, relJPT, ownerAttrName, RelType.ONE_TO_ONE,	1944	if (!fp.doesRelationExist(jpt, relJPT, ownerAttrName, RelType.ONE_TO_ONE,
1882	RelDir.BI))	1945	RelDir.BI))
Lines 2167-2172 Link Here
2167	Iterator<Connection> iter = Graphiti.getPeService().getAllConnections(cs).iterator();	2230	Iterator<Connection> iter = Graphiti.getPeService().getAllConnections(cs).iterator();
2168	while (iter.hasNext()) {	2231	while (iter.hasNext()) {
2169	Connection conn = iter.next();	2232	Connection conn = iter.next();
		2233	String v = Graphiti.getPeService().getPropertyValue(conn, IsARelation.IS_A_CONNECTION_PROP_KEY);
		2234	if (Boolean.TRUE.toString().equals(v))
		2235	continue;
2170	IRemoveContext ctx = new RemoveContext(conn);	2236	IRemoveContext ctx = new RemoveContext(conn);
2171	ctxs.add(ctx);	2237	ctxs.add(ctx);
2172	}	2238	}
Lines 2200-2205 Link Here
2200	}	2266	}
2201	}	2267	}
2202		2268
		2269	public void addIsARelations(IJPAEditorFeatureProvider fp,
		2270	Collection<IsARelation> rels) {
		2271	Iterator<IsARelation> it = rels.iterator();
		2272	while (it.hasNext()) {
		2273	IsARelation rel = it.next();
		2274	addNewIsARelation(fp, rel);
		2275	}
		2276	}
		2277
2203	private void addNewRelation(IJPAEditorFeatureProvider fp, IRelation rel) {	2278	private void addNewRelation(IJPAEditorFeatureProvider fp, IRelation rel) {
2204	AddConnectionContext ctx = new AddConnectionContext(JPAEditorUtil	2279	AddConnectionContext ctx = new AddConnectionContext(JPAEditorUtil
2205	.getAnchor(rel.getOwner(), fp), JPAEditorUtil.getAnchor(rel	2280	.getAnchor(rel.getOwner(), fp), JPAEditorUtil.getAnchor(rel
Lines 2212-2217 Link Here
2212	ft.add(ctx);	2287	ft.add(ctx);
2213	}	2288	}
2214		2289
		2290	private void addNewIsARelation(IJPAEditorFeatureProvider fp, IsARelation rel) {
		2291	AddConnectionContext ctx = new AddConnectionContext(JPAEditorUtil
		2292	.getAnchor(rel.getSubclass(), fp), JPAEditorUtil.getAnchor(rel.getSuperclass(), fp));
		2293	ctx.setNewObject(rel);
		2294	ctx.setTargetContainer(fp.getDiagramTypeProvider().getDiagram());
		2295	refreshEntityModel(fp, rel.getSubclass());
		2296	refreshEntityModel(fp, rel.getSuperclass());
		2297	AddInheritedEntityFeature ft = new AddInheritedEntityFeature(fp);
		2298	ft.add(ctx);
		2299	}
		2300
2215	private String getRelTypeName(RelationshipMappingAnnotation an,	2301	private String getRelTypeName(RelationshipMappingAnnotation an,
2216	JavaResourceAttribute jra) {	2302	JavaResourceAttribute jra) {
2217	String relTypeName = null;	2303	String relTypeName = null;
Lines 2252-2269 Link Here
2252	return res.toArray(ret);	2338	return res.toArray(ret);
2253	}	2339	}
2254		2340
2255	public boolean isId(JavaPersistentAttribute jpa) {	2341	// returns true even if the primary key is inherited
		2342	public boolean hasOrInheritsPrimaryKey(JavaPersistentType jpt) {
		2343	Iterable<ReadOnlyPersistentAttribute> attributes = jpt.getAllAttributes();
		2344	Iterator<ReadOnlyPersistentAttribute> it = attributes.iterator();
		2345	while (it.hasNext()) {
		2346	ReadOnlyPersistentAttribute at = it.next();
		2347	if (isId(at))
		2348	return true;
		2349	}
		2350	return false;
		2351	}
		2352
		2353	public boolean hasPrimaryKey(JavaPersistentType jpt) {
		2354	for (JavaPersistentAttribute at : jpt.getAttributes())
		2355	if (isId(at)) return true;
		2356	return false;
		2357	}
		2358
		2359
		2360	public boolean isId(ReadOnlyPersistentAttribute jpa) {
2256	return isSimpleId(jpa) \|\| isEmbeddedId(jpa);	2361	return isSimpleId(jpa) \|\| isEmbeddedId(jpa);
2257	}	2362	}
2258		2363
2259	public boolean isSimpleId(JavaPersistentAttribute jpa) {	2364	public boolean isSimpleId(ReadOnlyPersistentAttribute jpa) {
2260	IdAnnotation an = (IdAnnotation)jpa.getResourceAttribute().getAnnotation(IdAnnotation.ANNOTATION_NAME);	2365	return (jpa.getMappingKey() == MappingKeys.ID_ATTRIBUTE_MAPPING_KEY);
2261	return (an != null);
2262	}	2366	}
2263		2367
2264	public boolean isEmbeddedId(JavaPersistentAttribute jpa) {	2368	public boolean isEmbeddedId(ReadOnlyPersistentAttribute jpa) {
2265	EmbeddedIdAnnotation an = (EmbeddedIdAnnotation)jpa.getResourceAttribute().getAnnotation(EmbeddedIdAnnotation.ANNOTATION_NAME);	2369	return (jpa.getMappingKey() == MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY);
2266	return (an != null);
2267	}	2370	}
2268		2371
2269	public String getColumnName(JavaPersistentAttribute jpa) {	2372	public String getColumnName(JavaPersistentAttribute jpa) {
Lines 2278-2282 Link Here
2278	return columnName;	2381	return columnName;
2279	}	2382	}
2280		2383
		2384	public IColorConstant getForeground(JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot) {
		2385	IColorConstant foreground = dot.equals(JPAEditorConstants.DIAGRAM_OBJECT_TYPE.MappedSupeclass) ?
		2386	JPAEditorConstants.MAPPED_SUPERCLASS_BORDER_COLOR:
		2387	JPAEditorConstants.ENTITY_BORDER_COLOR;
		2388	return foreground;
		2389	}
2281		2390
		2391	public IColorConstant getBackground(JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot) {
		2392	IColorConstant background = dot.equals(JPAEditorConstants.DIAGRAM_OBJECT_TYPE.MappedSupeclass) ?
		2393	JPAEditorConstants.MAPPED_SUPERCLASS_BACKGROUND:
		2394	JPAEditorConstants.ENTITY_BACKGROUND;
		2395	return background;
		2396	}
		2397
		2398	public String getRenderingStyle(JPAEditorConstants.DIAGRAM_OBJECT_TYPE dot) {
		2399	String renderingStyle = dot.equals(JPAEditorConstants.DIAGRAM_OBJECT_TYPE.MappedSupeclass) ?
		2400	IJPAEditorPredefinedRenderingStyle.GREEN_WHITE_GLOSS_ID :
		2401	IJPAEditorPredefinedRenderingStyle.BLUE_WHITE_GLOSS_ID;
		2402	return renderingStyle;
		2403	}
		2404
		2405	public JPAEditorConstants.DIAGRAM_OBJECT_TYPE determineDiagramObjectType(JavaPersistentType jpt) {
		2406	if (this.hasEntityAnnotation(jpt)) {
		2407	return JPAEditorConstants.DIAGRAM_OBJECT_TYPE.Entity;
		2408	} else if (this.hasMappedSuperclassAnnotation(jpt)) {
		2409	return JPAEditorConstants.DIAGRAM_OBJECT_TYPE.MappedSupeclass;
		2410	}
		2411	throw new IllegalArgumentException();
		2412	}
		2413
		2414	public String generateIdName(JavaPersistentType jpt) {
		2415	String name = "id"; //$NON-NLS-1$
		2416	String genName = name;
		2417	for (int i = 0; i < 10000000; i++) {
		2418	if (!hasAttributeNamed(jpt, genName))
		2419	return genName;
		2420	genName = name + "_" + i; //$NON-NLS-1$
		2421	}
		2422	return genName;
		2423	}
		2424
		2425
		2426	private boolean hasAttributeNamed(JavaPersistentType jpt, String name) {
		2427	Iterable<String> hier = jpt.getAllAttributeNames();
		2428	Iterator<String> it = hier.iterator();
		2429	while (it.hasNext()) {
		2430	String atName = it.next();
		2431	if (name.equals(atName))
		2432	return true;
		2433	}
		2434	return false;
		2435	}
		2436
		2437	public String getMappedSuperclassPackageDeclaration(JavaPersistentType jpt) throws JavaModelException {
		2438	String packageName = null;
		2439	IPackageDeclaration[] packages = JPAEditorUtil.getCompilationUnit(jpt)
		2440	.getPackageDeclarations();
		2441	if (packages.length > 0) {
		2442	IPackageDeclaration packageDecl = packages[0];
		2443	packageName = packageDecl.getElementName();
		2444	}
		2445	return packageName;
		2446	}
		2447
		2448
2282	}	2449	}

Lines 76-82 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/feature/AddRelationFeatureTest.java (-6 / +6 lines)
76		76
77	private IAddConnectionContext context;	77	private IAddConnectionContext context;
78		78
79	private IPeServiceUtil peUtil;	79	private IPeServiceUtil peServiceUtil;
80		80
81	private IGaService gaUtil;	81	private IGaService gaUtil;
82		82
Lines 100-106 Link Here
100	diagramProvider = EasyMock.createMock(IDiagramTypeProvider.class);	100	diagramProvider = EasyMock.createMock(IDiagramTypeProvider.class);
101	diagram = EasyMock.createMock(Diagram.class);	101	diagram = EasyMock.createMock(Diagram.class);
102	context = EasyMock.createMock(IAddConnectionContext.class);	102	context = EasyMock.createMock(IAddConnectionContext.class);
103	peUtil = EasyMock.createMock(IPeServiceUtil.class);	103	peServiceUtil = EasyMock.createMock(IPeServiceUtil.class);
104	gaUtil = EasyMock.createMock(IGaService.class);	104	gaUtil = EasyMock.createMock(IGaService.class);
105	ft = EasyMock.createMock(IAddBendpointFeature.class);	105	ft = EasyMock.createMock(IAddBendpointFeature.class);
106		106
Lines 191-197 Link Here
191	Polyline pl = EasyMock.createMock(Polyline.class);	191	Polyline pl = EasyMock.createMock(Polyline.class);
192	expect(pl.getX()).andReturn(0);	192	expect(pl.getX()).andReturn(0);
193	expect(pl.getY()).andReturn(0);	193	expect(pl.getY()).andReturn(0);
194	expect(imageCreator.createArrowConnectionDecorator(isA(Connection.class), eq(location))).andReturn(d);	194	expect(imageCreator.createArrowConnectionDecorator(isA(Connection.class), eq(location), false)).andReturn(d);
195	expect(d.getGraphicsAlgorithm()).andReturn(pl);	195	expect(d.getGraphicsAlgorithm()).andReturn(pl);
196	replay(d, pl);	196	replay(d, pl);
197	}	197	}
Lines 213-219 Link Here
213	private void configureProvidersForAdd(IRelation relation) {	213	private void configureProvidersForAdd(IRelation relation) {
214	expect(diagramProvider.getDiagram()).andReturn(diagram);	214	expect(diagramProvider.getDiagram()).andReturn(diagram);
215	expect(featureProvider.getDiagramTypeProvider()).andReturn(diagramProvider);	215	expect(featureProvider.getDiagramTypeProvider()).andReturn(diagramProvider);
216	expect(featureProvider.getPeUtil()).andReturn(peUtil);	216	expect(featureProvider.getPeServiceUtil()).andReturn(peServiceUtil);
217	expect(featureProvider.getAddBendpointFeature(isA(IAddBendpointContext.class))).andStubReturn(ft);	217	expect(featureProvider.getAddBendpointFeature(isA(IAddBendpointContext.class))).andStubReturn(ft);
218	expect(context.getNewObject()).andReturn(relation);	218	expect(context.getNewObject()).andReturn(relation);
219		219
Lines 255-261 Link Here
255	gaUtil.setLocation(isA(Polyline.class), EasyMock.anyInt() , EasyMock.anyInt());	255	gaUtil.setLocation(isA(Polyline.class), EasyMock.anyInt() , EasyMock.anyInt());
256		256
257	FreeFormConnection connection = createConnection(startAnchor, endAnchor);	257	FreeFormConnection connection = createConnection(startAnchor, endAnchor);
258	expect(peUtil.createFreeFormConnection(diagram)).andReturn(connection);	258	expect(peServiceUtil.createFreeFormConnection(diagram)).andReturn(connection);
259	expect(imageCreator.createConnectionLine(diagram, connection)).andReturn(null);	259	expect(imageCreator.createConnectionLine(diagram, connection)).andReturn(null);
260	ft.addBendpoint(isA(IAddBendpointContext.class));	260	ft.addBendpoint(isA(IAddBendpointContext.class));
261		261
Lines 320-326 Link Here
320	replay(diagramProvider);	320	replay(diagramProvider);
321	replay(diagram);	321	replay(diagram);
322	replay(context);	322	replay(context);
323	replay(peUtil);	323	replay(peServiceUtil);
324	replay(gaUtil);	324	replay(gaUtil);
325	replay(ft);	325	replay(ft);
326	return new AddRelationFeature(featureProvider, imageCreator, jpaEditorUtil);	326	return new AddRelationFeature(featureProvider, imageCreator, jpaEditorUtil);