Attachment #207013 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.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.discoverAnnotatedClasses(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();
		JavaPersistentType jpt = JpaArtifactFactory.instance().getJPT(mappedSuperclassName, jpaProject);
		
		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);

Lines 298-303 Link Here

(-)src/org/eclipse/jpt/jpadiagrameditor/ui/internal/modelintegration/util/ModelIntegrationUtil.java (+2 lines)
298		298
299	public static JPAEditorDiagramTypeProvider getProviderByDiagram(String diagramName) {	299	public static JPAEditorDiagramTypeProvider getProviderByDiagram(String diagramName) {
300	IWorkbenchWindow workbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();	300	IWorkbenchWindow workbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
		301	if (workbenchWindow == null)
		302	return null;
301	IWorkbenchPage workbenchPage = workbenchWindow.getActivePage();	303	IWorkbenchPage workbenchPage = workbenchWindow.getActivePage();
302	IEditorReference[] editorRefs = workbenchPage.getEditorReferences();	304	IEditorReference[] editorRefs = workbenchPage.getEditorReferences();
303	for (IEditorReference editorRef : editorRefs) {	305	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().equals(getFirstSuperclassBelongingToTheDiagram(rel.getSubclass()))) {
					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 547-553 Link Here
547	Iterator<Connection> consIt = cons.iterator();	549	Iterator<Connection> consIt = cons.iterator();
548	while (consIt.hasNext()) {	550	while (consIt.hasNext()) {
549	Connection con = consIt.next();	551	Connection con = consIt.next();
550	ContainerShape cs1 = (ContainerShape)con.getStart().getParent();	552	ContainerShape cs1 = null;
		553	try {
		554	cs1 = (ContainerShape)con.getStart().getParent();
		555	} catch (NullPointerException e) {
		556	continue;
		557	}
551	if (cs1 != cs)	558	if (cs1 != cs)
552	res.add(cs1);	559	res.add(cs1);
553	cs1 = (ContainerShape)con.getEnd().getParent();	560	cs1 = (ContainerShape)con.getEnd().getParent();
Lines 858-864 Link Here
858	Iterator<Connection> cIter = set.iterator();	865	Iterator<Connection> cIter = set.iterator();
859	while (cIter.hasNext()) {	866	while (cIter.hasNext()) {
860	Connection c = cIter.next();	867	Connection c = cIter.next();
861	IRelation rel = (IRelation)fp.getBusinessObjectForPictogramElement(c);	868	Object o = fp.getBusinessObjectForPictogramElement(c);
		869	if (!(o instanceof IRelation))
		870	continue;
		871	IRelation rel = (IRelation)o;
862	rearrangeConnection(c, cnt, setSize, rel.getOwner() == rel.getInverse());	872	rearrangeConnection(c, cnt, setSize, rel.getOwner() == rel.getInverse());
863	cnt++;	873	cnt++;
864	}	874	}
Lines 1078-1084 Link Here
1078		1088
1079	static public String generateUniqueMappedSuperclassName(	1089	static public String generateUniqueMappedSuperclassName(
1080	JpaProject jpaProject, String pack, IJPAEditorFeatureProvider fp) {	1090	JpaProject jpaProject, String pack, IJPAEditorFeatureProvider fp) {
1081	String NAME = pack + ".MappedSuperclass"; //$NON-NLS-1$	1091	String NAME = pack + ".MpdSuprcls"; //$NON-NLS-1$
1082	String name = null;	1092	String name = null;
1083		1093
1084	HashSet<String> JPAProjectEntityNames = getEntityNames(jpaProject);	1094	HashSet<String> JPAProjectEntityNames = getEntityNames(jpaProject);
Lines 1095-1111 Link Here
1095	return name;	1105	return name;
1096	}	1106	}
1097		1107
1098		1108	static public IFile createEntityInProject(IProject project,
		1109	String entityName,
		1110	JavaPersistentType mappedSuperclass) throws Exception {
		1111	IFolder folder = getPackageFolder(project);
		1112	return createEntity(project, folder, entityName,
		1113	true, mappedSuperclass.getName(),
		1114	JpaArtifactFactory.instance().getMappedSuperclassPackageDeclaration(mappedSuperclass),
		1115	JpaArtifactFactory.instance().generateIdName(mappedSuperclass),
		1116	JpaArtifactFactory.instance().hasOrInheritsPrimaryKey(mappedSuperclass));
		1117	}
1099		1118
1100	static public IFile createEntityInProject(IProject project,	1119	static public IFile createEntityInProject(IProject project,
1101	String entityName, IPreferenceStore jpaPreferenceStore,	1120	String entityName, IPreferenceStore jpaPreferenceStore,
1102	boolean isMappedSuperclassChild, String mappedSuperclassName,	1121	boolean isMappedSuperclassChild, String mappedSuperclassName,
1103	String mappedSuperclassPackage, boolean hasPrimaryKey)	1122	String mappedSuperclassPackage, String idName, boolean hasPrimaryKey)
1104	throws Exception {	1123	throws Exception {
1105	IFolder folder = getPackageFolder(project);	1124	IFolder folder = getPackageFolder(project);
1106	return createEntity(project, folder, entityName,	1125	return createEntity(project, folder, entityName,
1107	isMappedSuperclassChild, mappedSuperclassName,	1126	isMappedSuperclassChild, mappedSuperclassName,
1108	mappedSuperclassPackage, hasPrimaryKey);	1127	mappedSuperclassPackage, idName, hasPrimaryKey);
1109	}	1128	}
1110		1129
1111		1130
Lines 1113-1120 Link Here
1113	IProject project, String mappedSuperclassName,	1132	IProject project, String mappedSuperclassName,
1114	IPreferenceStore jpaPreferenceStore) throws Exception {	1133	IPreferenceStore jpaPreferenceStore) throws Exception {
1115	IFolder folder = getPackageFolder(project);	1134	IFolder folder = getPackageFolder(project);
1116	createMappedSuperclass(project, folder, mappedSuperclassName);	1135	return createMappedSuperclassInProject(project, folder, mappedSuperclassName);
1117	return createMappedSuperclass(project, folder, mappedSuperclassName);
1118	}	1136	}
1119		1137
1120	@SuppressWarnings("deprecation")	1138	@SuppressWarnings("deprecation")
Lines 1141-1147 Link Here
1141		1159
1142	}	1160	}
1143		1161
1144	static private IFile createMappedSuperclass(IProject project,	1162	static public IFile createMappedSuperclassInProject(IProject project,
		1163	String mappedSuperclassName) throws Exception {
		1164	IFolder folder = getPackageFolder(project);
		1165	return createMappedSuperclassInProject(project, folder, mappedSuperclassName);
		1166	}
		1167
		1168	static public IFile createMappedSuperclassInProject(IProject project,
1145	IFolder folder, String mappedSuperclassName) throws Exception {	1169	IFolder folder, String mappedSuperclassName) throws Exception {
1146		1170
1147	String mappedSuperclassShortName = mappedSuperclassName	1171	String mappedSuperclassShortName = mappedSuperclassName
Lines 1286-1295 Link Here
1286	}	1310	}
1287	}	1311	}
1288		1312
1289	static private IFile createEntity(IProject project, IFolder folder, String entityName, boolean isMappedSuperclassChild,	1313	static private IFile createEntity(IProject project,
1290	String mappedSuperclassName, String mappedSuperclassPackage, boolean hasPrimaryKey) throws Exception {	1314	IFolder folder,
1291		1315	String entityName,
1292		1316	boolean isMappedSuperclassChild,
		1317	String mappedSuperclassName,
		1318	String mappedSuperclassPackage,
		1319	String idName,
		1320	boolean hasPrimaryKey) throws Exception {
1293		1321
1294	String entityShortName = entityName.substring(entityName.lastIndexOf('.') + 1);	1322	String entityShortName = entityName.substring(entityName.lastIndexOf('.') + 1);
1295	if (!folder.exists()) {	1323	if (!folder.exists()) {
Lines 1317-1344 Link Here
1317	}	1345	}
1318		1346
1319	String primaryKeyDeclaration = ""; //$NON-NLS-1$	1347	String primaryKeyDeclaration = ""; //$NON-NLS-1$
1320	if (!hasPrimaryKey) {	1348	if (!hasPrimaryKey)
1321	primaryKeyDeclaration = (fieldBasedAccess ? " @Id \n" : "") //$NON-NLS-1$ //$NON-NLS-2$	1349	primaryKeyDeclaration = generatePrimaryKeyDeclaration(fieldBasedAccess, idName);
1322	+ " private long id;\n\n" //$NON-NLS-1$
1323	+ (fieldBasedAccess ? "" : " @Id \n") //$NON-NLS-1$ //$NON-NLS-2$
1324	+ " public long getId() {\n" //$NON-NLS-1$
1325	+ " return id;\n" //$NON-NLS-1$
1326	+ " }\n\n" //$NON-NLS-1$
1327	+ " public void setId(long id) {\n" //$NON-NLS-1$
1328	+ " this.id = id;\n" //$NON-NLS-1$
1329	+ " }\n\n"; //$NON-NLS-1$
1330	}
1331
1332		1350
1333	if (!file.exists()) {	1351	if (!file.exists()) {
1334	String content = "package " + JPADiagramPropertyPage.getDefaultPackage(project, props) + ";\n\n" //$NON-NLS-1$ //$NON-NLS-2$	1352	String content = "package " + JPADiagramPropertyPage.getDefaultPackage(project, props) //$NON-NLS-1$
1335	+ "import javax.persistence.*;\n" //$NON-NLS-1$	1353	+ ";\n\n" //$NON-NLS-1$
1336	+ packageImport+"\n\n" //$NON-NLS-1$	1354	+ "import javax.persistence.*;\n" //$NON-NLS-1$
1337	+ "@Entity \n" //$NON-NLS-1$	1355	+ packageImport+"\n\n" //$NON-NLS-1$
1338	+ ((tableName.length() > 0) ? ("@Table(name=\"" + tableName + "\")\n") : "") //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$	1356	+ "@Entity \n" //$NON-NLS-1$
1339	+ classDeclarationStringContent	1357	+ ((tableName.length() > 0) ? ("@Table(name=\"" //$NON-NLS-1$
1340	+ primaryKeyDeclaration	1358	+ tableName + "\")\n") : "") //$NON-NLS-1$ //$NON-NLS-2$
1341	+"}"; //$NON-NLS-1$	1359	+ classDeclarationStringContent
		1360	+ primaryKeyDeclaration
		1361	+"}"; //$NON-NLS-1$
1342	ByteArrayOutputStream stream = new ByteArrayOutputStream();	1362	ByteArrayOutputStream stream = new ByteArrayOutputStream();
1343	try {	1363	try {
1344	stream.write(content.getBytes());	1364	stream.write(content.getBytes());
Lines 1349-1355 Link Here
1349	}	1369	}
1350	}	1370	}
1351	return file;	1371	return file;
1352	}	1372	}
		1373
		1374	static private String generatePrimaryKeyDeclaration(boolean fieldBasedAccess, String primaryKeyName) {
		1375	String primaryKeyDeclaration = (fieldBasedAccess ? " @Id \n" : "") //$NON-NLS-1$ //$NON-NLS-2$
		1376	+ " private long " + primaryKeyName + ";\n\n" //$NON-NLS-1$ //$NON-NLS-2$
		1377	+ (fieldBasedAccess ? "" : " @Id \n") //$NON-NLS-1$ //$NON-NLS-2$
		1378	+ " public long get" + capitalizeFirstLetter(primaryKeyName) + "() {\n" //$NON-NLS-1$ //$NON-NLS-2$
		1379	+ " return " + primaryKeyName + ";\n" //$NON-NLS-1$ //$NON-NLS-2$
		1380	+ " }\n\n" //$NON-NLS-1$
		1381	+ " public void set" + capitalizeFirstLetter(primaryKeyName) //$NON-NLS-1$
		1382	+ "(long " + primaryKeyName + ") {\n" //$NON-NLS-1$ //$NON-NLS-2$
		1383	+ " this." + primaryKeyName + " = " + primaryKeyName + ";\n" //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		1384	+ " }\n\n"; //$NON-NLS-1$
		1385	return primaryKeyDeclaration;
		1386	}
1353		1387
1354	static private HashSet<String> getEntityNames(JpaProject jpaProject) {	1388	static private HashSet<String> getEntityNames(JpaProject jpaProject) {
1355	HashSet<String> names = new HashSet<String>();	1389	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.common.core.JptResourceModel;
import org.eclipse.jpt.common.core.resource.java.Annotation;
import org.eclipse.jpt.common.core.resource.java.JavaResourceAbstractType;
import org.eclipse.jpt.common.core.resource.java.JavaResourceAnnotatedElement.Kind;
import org.eclipse.jpt.common.core.resource.java.JavaResourceAttribute;
import org.eclipse.jpt.common.core.resource.java.JavaResourceCompilationUnit;
import org.eclipse.jpt.common.core.resource.java.JavaResourceType;
import org.eclipse.jpt.common.core.resource.java.NestableAnnotation;
import org.eclipse.jpt.common.core.resource.java.JavaResourceAnnotatedElement.Kind;
import org.eclipse.jpt.common.utility.internal.iterables.ArrayListIterable;
import org.eclipse.jpt.common.utility.internal.iterables.SubListIterableWrapper;
import org.eclipse.jpt.jpa.core.JpaFile;

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,

		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,

		return null;
	}
	*/
	
	public JavaPersistentType getJPT(String name, JpaProject jpaProject) {
		ListIterator<PersistenceUnit> lit = jpaProject.getRootContextNode().getPersistenceXml().getPersistence().getPersistenceUnits().iterator();		
		PersistenceUnit pu = lit.next();
		return getJPT(name, pu);
	}
		
	public JavaPersistentType getJPT(String name, PersistenceUnit pu) {
		pu.getJpaProject().updateAndWait();

		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 189-199 Link Here
189	cont.setY(y);	192	cont.setY(y);
190	cont.setWidth(width);	193	cont.setWidth(width);
191	cont.setHeight(height);	194	cont.setHeight(height);
192	RoundedRectangle rect = AddJPAEntityFeature.createEntityRectangle(cont, cs, fp.getDiagramTypeProvider().getDiagram());	195	RoundedRectangle rect = AddJPAEntityFeature.createEntityRectangle(cont, cs, dot, fp.getDiagramTypeProvider().getDiagram());
193	rect.setFilled(true);	196	rect.setFilled(true);
194		197
195	IRemoveContext ctx = new RemoveContext(pict);	198	IRemoveContext ctx = new RemoveContext(pict);
196	RemoveJPAEntityFeature ft = new RemoveJPAEntityFeature(fp);	199	RemoveJPAEntityFeature ft = new RemoveJPAEntityFeature(fp, true);
197		200
198	boolean primaryCollapsed = JPAEditorConstants.TRUE_STRING.equals(Graphiti.getPeService().getPropertyValue(pict, JPAEditorConstants.PRIMARY_COLLAPSED));	201	boolean primaryCollapsed = JPAEditorConstants.TRUE_STRING.equals(Graphiti.getPeService().getPropertyValue(pict, JPAEditorConstants.PRIMARY_COLLAPSED));
199	boolean relationCollapsed = JPAEditorConstants.TRUE_STRING.equals(Graphiti.getPeService().getPropertyValue(pict, JPAEditorConstants.RELATION_COLLAPSED));	202	boolean relationCollapsed = JPAEditorConstants.TRUE_STRING.equals(Graphiti.getPeService().getPropertyValue(pict, JPAEditorConstants.RELATION_COLLAPSED));
Lines 216-222 Link Here
216	addCtx.setY(y);	219	addCtx.setY(y);
217	addCtx.setWidth(width);	220	addCtx.setWidth(width);
218	addCtx.setHeight(height);	221	addCtx.setHeight(height);
219	AddJPAEntityFeature ft1 = new AddJPAEntityFeature(fp);	222	AddJPAEntityFeature ft1 = new AddJPAEntityFeature(fp, true);
220	ft.remove(ctx);	223	ft.remove(ctx);
221	ft1.add(addCtx);	224	ft1.add(addCtx);
222	PictogramElement pe = fp.getPictogramElementForBusinessObject(newJPT);	225	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 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 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);