Attachment #225813 for bug #398451

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




import org.eclipse.emf.ecp.core.ECPProject;
import org.eclipse.emf.ecp.core.ECPProjectManager;
import org.eclipse.emf.ecp.core.util.observer.ECPObserverBus;
import org.eclipse.emf.ecp.core.util.observer.IECPProjectPreDeleteObserver;
import org.eclipse.emf.ecp.core.util.observer.IECPProjectsChangedUIObserver;
import org.eclipse.emf.ecp.emfstore.core.internal.EMFStoreProvider;
import org.eclipse.emf.ecp.emfstore.internal.ui.Activator;
import org.eclipse.emf.ecp.spi.core.InternalProject;

import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.jface.viewers.ILightweightLabelDecorator;

import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * @author Eugen Neufeld
 */
public class EMFStoreDirtyDecorator implements ILightweightLabelDecorator, CommitObserver, IECPProjectPreDeleteObserver {

	private String dirtyPath = "icons/dirty.png";
	private Map<ECPProject, EMFStoreDirtyObserver> observers = new HashMap<ECPProject, EMFStoreDirtyObserver>();

	/**
	 * Instantiates a new EMFStoreDirtyDecorator.
	 */
	public EMFStoreDirtyDecorator() {
		super();
		ECPObserverBus.getInstance().register(this);
	}

	private class EMFStoreDirtyDecoratorConnector implements IECPProjectObjectsChangedObserver,
		IECPProjectsChangedUIObserver {

		/** {@inheritDoc} */
		public Object[] objectsChanged(ECPProject project, Object[] objects) throws Exception {
			if (project.getRepository() == null) {
				return null;
			}
			Set<EObject> allObjects = new HashSet<EObject>();
			for (EMFStoreDirtyObserver observer : observers.values()) {
				allObjects.addAll(observer.getLastAffected());
			}
			return allObjects.toArray();
		}

		/** {@inheritDoc} */
		public void projectsChanged(ECPProject[] oldProjects, ECPProject[] newProjects) throws Exception {
			Set<ECPProject> removed = new HashSet<ECPProject>(Arrays.asList(oldProjects));
			removed.removeAll(Arrays.asList(newProjects));

			for (ECPProject project : removed) {
				observers.remove(project);
				EMFStoreDirtyDecoratorCachedTree.getInstance(project).clear();
			}
		}

		/** {@inheritDoc} */
		public void projectChanged(ECPProject project, boolean opened) throws Exception {
			// Do nothing
		}

		/** {@inheritDoc} */
		public void objectsChanged(ECPProject project, Object[] objects, boolean structural) throws Exception {
			// Do nothing
		}

	}

	/** {@inheritDoc} */
	public void decorate(Object element, IDecoration decoration) {

		if (element instanceof ECPProject) {
			InternalProject project = (InternalProject) element;
			if (ECPProjectManager.INSTANCE.getProject(project.getName()) == null) {
				return;
			}
			ProjectSpace projectSpace = EMFStoreProvider.INSTANCE.getProjectSpace(project);

			if (!observers.containsKey(element)) {
				EMFStoreDirtyObserver emfStoreDirtyObserver = new EMFStoreDirtyObserver(projectSpace, project);
				projectSpace.getOperationManager().addOperationListener(emfStoreDirtyObserver);
				observers.put((ECPProject) element, emfStoreDirtyObserver);
			}
			if (project.isOpen() && EMFStoreProvider.INSTANCE.getProjectSpace(project).isShared()
				&& EMFStoreDirtyDecoratorCachedTree.getInstance(project).getRootValue() > 0) {
				decoration.addOverlay(Activator.getImageDescriptor(dirtyPath), IDecoration.BOTTOM_LEFT);
			}
		}

			} catch (IllegalArgumentException iae) {
				// ignore
			}
			if (project != null && project.isOpen() && EMFStoreProvider.INSTANCE.getProjectSpace(project).isShared()
				&& EMFStoreDirtyDecoratorCachedTree.getInstance(project).getCachedValue(element) > 0) {
				&& EMFStoreProvider.INSTANCE.getProjectSpace(project).isShared()
				&& EMFStoreDirtyDecoratorCachedTree.getInstance(project).getCachedValue(element)
					.shouldDisplayDirtyIndicator()) {
				decoration.addOverlay(Activator.getImageDescriptor(dirtyPath), IDecoration.BOTTOM_LEFT);
			} else {
				decoration.addOverlay(null);

		ECPProject project = EMFStoreProvider.INSTANCE.getProject(projectSpace);
		EMFStoreDirtyDecoratorCachedTree.getInstance(project).clear();
	}

	/** {@inheritDoc} */
	public void projectDelete(ECPProject project) {
		EMFStoreDirtyDecoratorCachedTree.getInstance(project).clear();
		observers.remove(project);
	}
}




 * @author emueller
 * 
 */
public final class EMFStoreDirtyDecoratorCachedTree extends AbstractCachedTree<Integer> {

	private static Map<ECPProject, EMFStoreDirtyDecoratorCachedTree> cashedTrees = new HashMap<ECPProject, EMFStoreDirtyDecoratorCachedTree>();


	/**
	 * Cached tree node that stores the dirty state of a model element managed by EMFStore.
	 */
	public class CachedDirtyStateTreeNode extends CachedTreeNode<Integer> {

		/**
		 * Constructor.

		 * @param value
		 *            the initial value for this entry
		 */
		public CachedDirtyStateTreeNode(Integer value) {
			super(0);
			setChildValue(getDefaultValue());
		}

		/**

		 */
		@Override
		public void update() {
			setChildValue(getDefaultValue());
			for (Integer value : values()) {
				if (value > getChildValue()) {
					setChildValue(value);
					break;
				}
			}
			getOwnValue().setChildChanges(false);
		}

		/*

		 * @see org.eclipse.emf.ecp.ui.common.CachedTreeNode#getDisplayValue()
		 */
		@Override
		public Integer getDisplayValue() {
			return getChildValue() > 0 || getOwnValue() > 0 ? 1 : 0;
		}
	}


	 * {@inheritDoc}
	 */
	@Override
	public Integer getDefaultValue() {
		return 0;
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	public CachedTreeNode<Integer> createdCachedTreeNode(Integer t) {
		return new CachedDirtyStateTreeNode(t);
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	protected void updateParentNode(Object parent, Object object, EMFStoreDirtyTreeNode value) {
		EMFStoreDirtyTreeNode parentValue = getCachedValue(parent);
		parentValue.setChildChanges(value.shouldDisplayDirtyIndicator());
		super.updateParentNode(parent, object, parentValue);
	}

	/**

	 * @return the {@link Set} of {@link EObject} affected by this change
	 */
	public Set<EObject> addOperation(EObject eObject) {
		int value = 0;
		CachedTreeNode<Integer> node = nodes.get(eObject);
		if (node != null) {
			value = node.getOwnValue();
		}
		return update(eObject, ++value);
	}

	/**

	 * @return the {@link Set} of {@link EObject} affected by this change
	 */
	public Set<EObject> removeOperation(EObject eObject) {
		int value = 0;
		CachedTreeNode<Integer> node = nodes.get(eObject);
		if (node != null) {
			value = node.getOwnValue();
		}
		return update(eObject, Math.max(0, --value));
		// if (childNode.shouldDisplayDirtyIndicator()) {
		// hasChanges = true;
		// break;
		// }
		// }
		// node.setChildChanges(hasChanges);
		return update(eObject, node);
	}
}

Lines 20-25 Link Here

(-)src/org/eclipse/emf/ecp/emfstore/internal/ui/decorator/EMFStoreDirtyObserver.java (-2 / +7 lines)
20	import org.eclipse.emf.emfstore.common.model.Project;	20	import org.eclipse.emf.emfstore.common.model.Project;
21	import org.eclipse.emf.emfstore.server.model.versioning.operations.AbstractOperation;	21	import org.eclipse.emf.emfstore.server.model.versioning.operations.AbstractOperation;
22		22
		23	import org.eclipse.ui.IDecoratorManager;
		24	import org.eclipse.ui.PlatformUI;
		25
23	import java.util.HashSet;	26	import java.util.HashSet;
24	import java.util.Set;	27	import java.util.Set;
25		28
Lines 74-86 Link Here
74	lastAffected	77	lastAffected
75	.addAll(EMFStoreDirtyDecoratorCachedTree.getInstance(internalProject).addOperation(element));	78	.addAll(EMFStoreDirtyDecoratorCachedTree.getInstance(internalProject).addOperation(element));
76	}	79	}
		80	IDecoratorManager decoratorManager = PlatformUI.getWorkbench().getDecoratorManager();
		81	decoratorManager.update("org.eclipse.emf.ecp.emfstore.ui.decorators.EMFStoreDirtyDecorator");
77	}	82	}
78		83
79	}	84	}
80		85
81	/** {@inheritDoc} */	86	/** {@inheritDoc} */
82	public void operationUnDone(AbstractOperation operation) {	87	public void operationUnDone(AbstractOperation operation) {
83
84	if (!projectSpace.isShared()) {	88	if (!projectSpace.isShared()) {
85	return;	89	return;
86	}	90	}
Lines 94-101 Link Here
94	lastAffected.addAll(EMFStoreDirtyDecoratorCachedTree.getInstance(internalProject).removeOperation(	98	lastAffected.addAll(EMFStoreDirtyDecoratorCachedTree.getInstance(internalProject).removeOperation(
95	element));	99	element));
96	}	100	}
		101	IDecoratorManager decoratorManager = PlatformUI.getWorkbench().getDecoratorManager();
		102	decoratorManager.update("org.eclipse.emf.ecp.emfstore.ui.decorators.EMFStoreDirtyDecorator");
97	}	103	}
98
99	}	104	}
100		105
101	/**	106	/**

Lines 35-41 Link Here

(-)src/org/eclipse/emf/ecp/ui/common/AbstractCachedTree.java (-2 / +2 lines)
35	*/	35	*/
36	public abstract class AbstractCachedTree<T> {	36	public abstract class AbstractCachedTree<T> {
37		37
38	private Map<Object, CachedTreeNode<T>> nodes;	38	protected Map<Object, CachedTreeNode<T>> nodes;
39	private CachedTreeNode<T> rootValue;	39	private CachedTreeNode<T> rootValue;
40	private IExcludedObjectsCallback excludedCallback;	40	private IExcludedObjectsCallback excludedCallback;
41		41
Lines 209-215 Link Here
209	node.setParent(parent);	209	node.setParent(parent);
210		210
211	if (parentNode == null) {	211	if (parentNode == null) {
212	parentNode = createNodeEntry(parent, value);	212	parentNode = createNodeEntry(parent, getDefaultValue());
213	}	213	}
214		214
215	parentNode.putIntoCache(object, value);	215	parentNode.putIntoCache(object, value);




import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecp.core.ECPProject;
import org.eclipse.emf.ecp.core.ECPProjectManager;
import org.eclipse.emf.ecp.internal.core.ECPProjectManagerImpl;
import org.eclipse.emf.ecp.spi.core.InternalProject;
import org.eclipse.jface.viewers.IDecoration;
import org.eclipse.jface.viewers.ILightweightLabelDecorator;
import org.eclipse.jface.viewers.LabelProvider;

	 * {@inheritDoc}
	 */
	public void decorate(final Object element, IDecoration decoration) {
		
		
		if (!(element instanceof EObject) && !(element instanceof ECPProject)) {
			return;
		}

				severity = Activator.getDefault().getValidationService(project).getDiagnostic(element).getSeverity();
			}
		} else if (element instanceof ECPProject && ((ECPProject)element).isOpen()) {
			if (ECPProjectManager.INSTANCE.getProject(((ECPProject) element).getName()) == null) {
				return;
			}
			severity = Activator.getDefault().getValidationService((ECPProject) element).getRootDiagnostic().getSeverity();
		}
		

Return to bug 398451

Lines 16-23 Link Here

(-)src/org/eclipse/emf/ecp/emfstore/internal/ui/decorator/EMFStoreDirtyDecorator.java (-55 / +21 lines)
16	import org.eclipse.emf.ecp.core.ECPProject;	16	import org.eclipse.emf.ecp.core.ECPProject;
17	import org.eclipse.emf.ecp.core.ECPProjectManager;	17	import org.eclipse.emf.ecp.core.ECPProjectManager;
18	import org.eclipse.emf.ecp.core.util.observer.ECPObserverBus;	18	import org.eclipse.emf.ecp.core.util.observer.ECPObserverBus;
19	import org.eclipse.emf.ecp.core.util.observer.IECPProjectObjectsChangedObserver;	19	import org.eclipse.emf.ecp.core.util.observer.IECPProjectPreDeleteObserver;
20	import org.eclipse.emf.ecp.core.util.observer.IECPProjectsChangedUIObserver;
21	import org.eclipse.emf.ecp.emfstore.core.internal.EMFStoreProvider;	20	import org.eclipse.emf.ecp.emfstore.core.internal.EMFStoreProvider;
22	import org.eclipse.emf.ecp.emfstore.internal.ui.Activator;	21	import org.eclipse.emf.ecp.emfstore.internal.ui.Activator;
23	import org.eclipse.emf.ecp.spi.core.InternalProject;	22	import org.eclipse.emf.ecp.spi.core.InternalProject;
Lines 30-106 Link Here
30	import org.eclipse.jface.viewers.ILabelProviderListener;	29	import org.eclipse.jface.viewers.ILabelProviderListener;
31	import org.eclipse.jface.viewers.ILightweightLabelDecorator;	30	import org.eclipse.jface.viewers.ILightweightLabelDecorator;
32		31
33	import java.util.Arrays;
34	import java.util.HashMap;	32	import java.util.HashMap;
35	import java.util.HashSet;
36	import java.util.Map;	33	import java.util.Map;
37	import java.util.Set;
38		34
39	/**	35	/**
40	* @author Eugen Neufeld	36	* @author Eugen Neufeld
41	*/	37	*/
42	public class EMFStoreDirtyDecorator implements ILightweightLabelDecorator, CommitObserver {	38	public class EMFStoreDirtyDecorator implements ILightweightLabelDecorator, CommitObserver, IECPProjectPreDeleteObserver {
43		39
44	private String dirtyPath = "icons/dirty.png";	40	private String dirtyPath = "icons/dirty.png";
45	private Map<InternalProject, EMFStoreDirtyObserver> observers = new HashMap<InternalProject, EMFStoreDirtyObserver>();	41	private Map<ECPProject, EMFStoreDirtyObserver> observers = new HashMap<ECPProject, EMFStoreDirtyObserver>();
46		42
		43	/**
		44	* Instantiates a new EMFStoreDirtyDecorator.
		45	*/
47	public EMFStoreDirtyDecorator() {	46	public EMFStoreDirtyDecorator() {
48	EMFStoreDirtyDecoratorConnector con = new EMFStoreDirtyDecoratorConnector();	47	super();
49	ECPObserverBus.getInstance().register(con);	48	ECPObserverBus.getInstance().register(this);
50	}
51
52	private class EMFStoreDirtyDecoratorConnector implements IECPProjectObjectsChangedObserver,
53	IECPProjectsChangedUIObserver {
54
55	/** {@inheritDoc} */
56	public Object[] objectsChanged(ECPProject project, Object[] objects) throws Exception {
57	if (project.getRepository() == null) {
58	return null;
59	}
60	Set<EObject> allObjects = new HashSet<EObject>();
61	for (EMFStoreDirtyObserver observer : observers.values()) {
62	allObjects.addAll(observer.getLastAffected());
63	}
64	return allObjects.toArray();
65	}
66
67	/** {@inheritDoc} */
68	public void projectsChanged(ECPProject[] oldProjects, ECPProject[] newProjects) throws Exception {
69	Set<ECPProject> removed = new HashSet<ECPProject>(Arrays.asList(oldProjects));
70	removed.removeAll(Arrays.asList(newProjects));
71
72	for (ECPProject project : removed) {
73	observers.remove(project);
74	EMFStoreDirtyDecoratorCachedTree.getInstance(project).clear();
75	}
76	}
77
78	/** {@inheritDoc} */
79	public void projectChanged(ECPProject project, boolean opened) throws Exception {
80	// Do nothing
81	}
82
83	/** {@inheritDoc} */
84	public void objectsChanged(ECPProject project, Object[] objects, boolean structural) throws Exception {
85	// Do nothing
86	}
87
88	}	49	}
89		50
90	/** {@inheritDoc} */	51	/** {@inheritDoc} */
91	public void decorate(Object element, IDecoration decoration) {	52	public void decorate(Object element, IDecoration decoration) {
92
93	if (element instanceof ECPProject) {	53	if (element instanceof ECPProject) {
94	InternalProject project = (InternalProject) element;	54	InternalProject project = (InternalProject) element;
		55	if (ECPProjectManager.INSTANCE.getProject(project.getName()) == null) {
		56	return;
		57	}
95	ProjectSpace projectSpace = EMFStoreProvider.INSTANCE.getProjectSpace(project);	58	ProjectSpace projectSpace = EMFStoreProvider.INSTANCE.getProjectSpace(project);
96		59
97	if (!observers.containsKey(element)) {	60	if (!observers.containsKey(element)) {
98	EMFStoreDirtyObserver emfStoreDirtyObserver = new EMFStoreDirtyObserver(projectSpace, project);	61	EMFStoreDirtyObserver emfStoreDirtyObserver = new EMFStoreDirtyObserver(projectSpace, project);
99	projectSpace.getOperationManager().addOperationListener(emfStoreDirtyObserver);	62	projectSpace.getOperationManager().addOperationListener(emfStoreDirtyObserver);
100	observers.put(project, emfStoreDirtyObserver);	63	observers.put((ECPProject) element, emfStoreDirtyObserver);
101	}	64	}
102	if (project.isOpen() && EMFStoreProvider.INSTANCE.getProjectSpace(project).isShared()	65	if (project.isOpen() && EMFStoreProvider.INSTANCE.getProjectSpace(project).isShared()
103	&& EMFStoreDirtyDecoratorCachedTree.getInstance(project).getRootValue().shouldDisplayDirtyIndicator()) {	66	&& EMFStoreDirtyDecoratorCachedTree.getInstance(project).getRootValue() > 0) {
104	decoration.addOverlay(Activator.getImageDescriptor(dirtyPath), IDecoration.BOTTOM_LEFT);	67	decoration.addOverlay(Activator.getImageDescriptor(dirtyPath), IDecoration.BOTTOM_LEFT);
105	}	68	}
106	}	69	}
Lines 112-122 Link Here
112	} catch (IllegalArgumentException iae) {	75	} catch (IllegalArgumentException iae) {
113	// ignore	76	// ignore
114	}	77	}
115	if (project != null	78	if (project != null && project.isOpen() && EMFStoreProvider.INSTANCE.getProjectSpace(project).isShared()
116	&& project.isOpen()	79	&& EMFStoreDirtyDecoratorCachedTree.getInstance(project).getCachedValue(element) > 0) {
117	&& EMFStoreProvider.INSTANCE.getProjectSpace(project).isShared()
118	&& EMFStoreDirtyDecoratorCachedTree.getInstance(project).getCachedValue(element)
119	.shouldDisplayDirtyIndicator()) {
120	decoration.addOverlay(Activator.getImageDescriptor(dirtyPath), IDecoration.BOTTOM_LEFT);	80	decoration.addOverlay(Activator.getImageDescriptor(dirtyPath), IDecoration.BOTTOM_LEFT);
121	} else {	81	} else {
122	decoration.addOverlay(null);	82	decoration.addOverlay(null);
Lines 153-156 Link Here
153	ECPProject project = EMFStoreProvider.INSTANCE.getProject(projectSpace);	113	ECPProject project = EMFStoreProvider.INSTANCE.getProject(projectSpace);
154	EMFStoreDirtyDecoratorCachedTree.getInstance(project).clear();	114	EMFStoreDirtyDecoratorCachedTree.getInstance(project).clear();
155	}	115	}
		116
		117	/** {@inheritDoc} */
		118	public void projectDelete(ECPProject project) {
		119	EMFStoreDirtyDecoratorCachedTree.getInstance(project).clear();
		120	observers.remove(project);
		121	}
156	}	122	}

Lines 28-34 Link Here

(-)src/org/eclipse/emf/ecp/emfstore/internal/ui/decorator/EMFStoreDirtyDecoratorCachedTree.java (-40 / +27 lines)
28	* @author emueller	28	* @author emueller
29	*	29	*
30	*/	30	*/
31	public final class EMFStoreDirtyDecoratorCachedTree extends AbstractCachedTree<EMFStoreDirtyTreeNode> {	31	public final class EMFStoreDirtyDecoratorCachedTree extends AbstractCachedTree<Integer> {
32		32
33	private static Map<ECPProject, EMFStoreDirtyDecoratorCachedTree> cashedTrees = new HashMap<ECPProject, EMFStoreDirtyDecoratorCachedTree>();	33	private static Map<ECPProject, EMFStoreDirtyDecoratorCachedTree> cashedTrees = new HashMap<ECPProject, EMFStoreDirtyDecoratorCachedTree>();
34		34
Lines 60-66 Link Here
60	/**	60	/**
61	* Cached tree node that stores the dirty state of a model element managed by EMFStore.	61	* Cached tree node that stores the dirty state of a model element managed by EMFStore.
62	*/	62	*/
63	public class CachedDirtyStateTreeNode extends CachedTreeNode<EMFStoreDirtyTreeNode> {	63	public class CachedDirtyStateTreeNode extends CachedTreeNode<Integer> {
64		64
65	/**	65	/**
66	* Constructor.	66	* Constructor.
Lines 68-75 Link Here
68	* @param value	68	* @param value
69	* the initial value for this entry	69	* the initial value for this entry
70	*/	70	*/
71	public CachedDirtyStateTreeNode(EMFStoreDirtyTreeNode value) {	71	public CachedDirtyStateTreeNode(Integer value) {
72	super(value);	72	super(0);
		73	setChildValue(getDefaultValue());
73	}	74	}
74		75
75	/**	76	/**
Lines 77-89 Link Here
77	*/	78	*/
78	@Override	79	@Override
79	public void update() {	80	public void update() {
80	for (EMFStoreDirtyTreeNode node : values()) {	81	setChildValue(getDefaultValue());
81	if (node.getChangeCount() > 0 \|\| node.isChildChanges()) {	82	for (Integer value : values()) {
82	getOwnValue().setChildChanges(true);	83	if (value > getChildValue()) {
83	return;	84	setChildValue(value);
		85	break;
84	}	86	}
85	}	87	}
86	getOwnValue().setChildChanges(false);
87	}	88	}
88		89
89	/*	90	/*
Lines 91-98 Link Here
91	* @see org.eclipse.emf.ecp.ui.common.CachedTreeNode#getDisplayValue()	92	* @see org.eclipse.emf.ecp.ui.common.CachedTreeNode#getDisplayValue()
92	*/	93	*/
93	@Override	94	@Override
94	public EMFStoreDirtyTreeNode getDisplayValue() {	95	public Integer getDisplayValue() {
95	return getOwnValue();	96	return getChildValue() > 0 \|\| getOwnValue() > 0 ? 1 : 0;
96	}	97	}
97	}	98	}
98		99
Lines 100-125 Link Here
100	* {@inheritDoc}	101	* {@inheritDoc}
101	*/	102	*/
102	@Override	103	@Override
103	public EMFStoreDirtyTreeNode getDefaultValue() {	104	public Integer getDefaultValue() {
104	return new EMFStoreDirtyTreeNode(0, false);	105	return 0;
105	}	106	}
106		107
107	/**	108	/**
108	* {@inheritDoc}	109	* {@inheritDoc}
109	*/	110	*/
110	@Override	111	@Override
111	public CachedTreeNode<EMFStoreDirtyTreeNode> createdCachedTreeNode(EMFStoreDirtyTreeNode t) {	112	public CachedTreeNode<Integer> createdCachedTreeNode(Integer t) {
112	return new CachedDirtyStateTreeNode(t);	113	return new CachedDirtyStateTreeNode(t);
113	}
114
115	/**
116	* {@inheritDoc}
117	*/
118	@Override
119	protected void updateParentNode(Object parent, Object object, EMFStoreDirtyTreeNode value) {
120	EMFStoreDirtyTreeNode parentValue = getCachedValue(parent);
121	parentValue.setChildChanges(value.shouldDisplayDirtyIndicator());
122	super.updateParentNode(parent, object, parentValue);
123	}	114	}
124		115
125	/**	116	/**
Lines 129-137 Link Here
129	* @return the {@link Set} of {@link EObject} affected by this change	120	* @return the {@link Set} of {@link EObject} affected by this change
130	*/	121	*/
131	public Set<EObject> addOperation(EObject eObject) {	122	public Set<EObject> addOperation(EObject eObject) {
132	EMFStoreDirtyTreeNode node = getCachedValue(eObject);	123	int value = 0;
133	node.setChangeCount(node.getChangeCount() + 1);	124	CachedTreeNode<Integer> node = nodes.get(eObject);
134	return update(eObject, node);	125	if (node != null) {
		126	value = node.getOwnValue();
		127	}
		128	return update(eObject, ++value);
135	}	129	}
136		130
137	/**	131	/**
Lines 141-158 Link Here
141	* @return the {@link Set} of {@link EObject} affected by this change	135	* @return the {@link Set} of {@link EObject} affected by this change
142	*/	136	*/
143	public Set<EObject> removeOperation(EObject eObject) {	137	public Set<EObject> removeOperation(EObject eObject) {
144	EMFStoreDirtyTreeNode node = getCachedValue(eObject);	138	int value = 0;
145	node.setChangeCount(node.getChangeCount() - 1);	139	CachedTreeNode<Integer> node = nodes.get(eObject);
146	// TODO @TOBI: why?	140	if (node != null) {
147	// boolean hasChanges = false;	141	value = node.getOwnValue();
148	// for (EObject child : eObject.eContents()) {	142	}
149	// EMFStoreDirtyTreeNode childNode = getCachedValue(child);	143	return update(eObject, Math.max(0, --value));
150	// if (childNode.shouldDisplayDirtyIndicator()) {
151	// hasChanges = true;
152	// break;
153	// }
154	// }
155	// node.setChildChanges(hasChanges);
156	return update(eObject, node);
157	}	144	}
158	}	145	}

Lines 16-23 Link Here

(-)src/org/eclipse/emf/ecp/validation/connector/ValidationFailedDecorator.java (-3 / +5 lines)
16	import org.eclipse.emf.ecore.EObject;	16	import org.eclipse.emf.ecore.EObject;
17	import org.eclipse.emf.ecp.core.ECPProject;	17	import org.eclipse.emf.ecp.core.ECPProject;
18	import org.eclipse.emf.ecp.core.ECPProjectManager;	18	import org.eclipse.emf.ecp.core.ECPProjectManager;
19	import org.eclipse.emf.ecp.internal.core.ECPProjectManagerImpl;
20	import org.eclipse.emf.ecp.spi.core.InternalProject;
21	import org.eclipse.jface.viewers.IDecoration;	19	import org.eclipse.jface.viewers.IDecoration;
22	import org.eclipse.jface.viewers.ILightweightLabelDecorator;	20	import org.eclipse.jface.viewers.ILightweightLabelDecorator;
23	import org.eclipse.jface.viewers.LabelProvider;	21	import org.eclipse.jface.viewers.LabelProvider;
Lines 34-40 Link Here
34	* {@inheritDoc}	32	* {@inheritDoc}
35	*/	33	*/
36	public void decorate(final Object element, IDecoration decoration) {	34	public void decorate(final Object element, IDecoration decoration) {
37		35
		36
38	if (!(element instanceof EObject) && !(element instanceof ECPProject)) {	37	if (!(element instanceof EObject) && !(element instanceof ECPProject)) {
39	return;	38	return;
40	}	39	}
Lines 49-54 Link Here
49	severity = Activator.getDefault().getValidationService(project).getDiagnostic(element).getSeverity();	48	severity = Activator.getDefault().getValidationService(project).getDiagnostic(element).getSeverity();
50	}	49	}
51	} else if (element instanceof ECPProject && ((ECPProject)element).isOpen()) {	50	} else if (element instanceof ECPProject && ((ECPProject)element).isOpen()) {
		51	if (ECPProjectManager.INSTANCE.getProject(((ECPProject) element).getName()) == null) {
		52	return;
		53	}
52	severity = Activator.getDefault().getValidationService((ECPProject) element).getRootDiagnostic().getSeverity();	54	severity = Activator.getDefault().getValidationService((ECPProject) element).getRootDiagnostic().getSeverity();
53	}	55	}
54		56