Bug 485220: [Architecture] Provide a more modular architecture

https://bugs.eclipse.org/bugs/show_bug.cgi?id=485220

Factor UI dependencies out of the UML Element Types bundle.  This includes
moving some advices that interact with the user into a new
org.eclipse.papyrus.uml.service.types.ui bundle.

Pull up the PasteCommandService and IPasteCommandProvider API into the
Infra Diagram layer where the extension point is defined.  Deprecate the
old API in the UML layer.

Introduce a service for participation of languages in CSS styling:

* styling reset actions in the Reset Style command
* access to semantic model classes and properties to make available to CSS

Factor PapyrusObservableValue and cohorts out of the UML Tools bundle
into the Infra Layer for more general reuse and to relieve the
Diagram Infrastructure layer of UML dependencies.  The old API remains as
deprecated.

Remove the Infra Diagram Layer dependency on UML Layer for property
testers governing deletion in the diagram.  Includes introduction of
a new IGraphicalDeletionHelper OSGi service for delegation of the
determination of whether an element can be deleted from the diagram and
replacement of the XML expression properties

* org.eclipse.papyrus.uml.diagram.common.isSemanticDeletion
* org.eclipse.papyrus.uml.diagram.common.isReadOnly

by

* org.eclipse.papyrus.infra.gmfdiag.common.isSemanticDeletion
* org.eclipse.papyrus.infra.gmfdiag.common.canDelete

(where the latter is the negation of the property that it supersedes)

Extract UML dependencies from the Diagram Outline and CSS Editor bundles.

Remove unused MDTUtil APIs that referenced a UML-specific annotation.

Move the Diagram Infrastructure CSS Palette bundle into the UML layer because it
serves to provide extensions on the Palette Service, which is an overtly
UML-specific capability.

All client APIs for the Properties View are moved from
org.eclipse.papyrus.views.properties bundle to a new
org.eclipse.papyrus.infra.properties.ui bundle.  This
includes renaming of:

* extension points
* label-provider contexts
* XWT namespaces

Add an "all UI tests" suite.

Define a componentized hierarchical build layout of the main plug-ins

Change-Id: I43f8f3644857a18b69715f5a2f1da9b1cf286d67

1 files changed, 347 insertions, 0 deletions

diff --git a/plugins/infra/core/org.eclipse.papyrus.infra.tools/src/org/eclipse/papyrus/infra/tools/databinding/DelegatingObservable.java b/plugins/infra/core/org.eclipse.papyrus.infra.tools/src/org/eclipse/papyrus/infra/tools/databinding/DelegatingObservable.java
new file mode 100644
index 00000000000..7f2f0206e20
--- /dev/null
+++ b/plugins/infra/core/org.eclipse.papyrus.infra.tools/src/org/eclipse/papyrus/infra/tools/databinding/DelegatingObservable.java
@@ -0,0 +1,347 @@
+/*
+ * Copyright (c) 2014 CEA and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *   Christian W. Damus (CEA) - Initial API and implementation
+ *
+ */
+package org.eclipse.papyrus.infra.tools.databinding;
+
+import java.lang.reflect.Proxy;
+
+import org.eclipse.core.databinding.observable.ChangeEvent;
+import org.eclipse.core.databinding.observable.DisposeEvent;
+import org.eclipse.core.databinding.observable.IChangeListener;
+import org.eclipse.core.databinding.observable.IDisposeListener;
+import org.eclipse.core.databinding.observable.IObservable;
+import org.eclipse.core.databinding.observable.IObserving;
+import org.eclipse.core.databinding.observable.IStaleListener;
+import org.eclipse.core.databinding.observable.ObservableEvent;
+import org.eclipse.core.databinding.observable.ObservableTracker;
+import org.eclipse.core.databinding.observable.Realm;
+import org.eclipse.core.databinding.observable.StaleEvent;
+import org.eclipse.core.databinding.observable.list.IObservableList;
+import org.eclipse.core.databinding.observable.set.IObservableSet;
+import org.eclipse.core.databinding.observable.value.IObservableValue;
+
+
+/**
+ * Abstract implementation of the {@link IDelegatingObservable} protocol with factory methods for creation of delegators.
+ *
+ * @see #wrap(IObservable)
+ * @see #create(Realm, Class)
+ * @see #create(Realm, Class, ClassLoader, Class...)
+ */
+public abstract class DelegatingObservable<T extends IObservable> extends ReferenceCountedObservable.Abstract implements IDelegatingObservable {
+
+	private final Class<T> delegateType;
+
+	private T delegate;
+
+	@SuppressWarnings("unchecked")
+	private T realObservable = (T) this;
+
+	private IChangeListener forwardingChangeListener;
+
+	private IStaleListener forwardingStaleListener;
+
+	private IDisposeListener delegateDisposeListener;
+
+	DelegatingObservable(T delegate, Class<T> delegateType) {
+		super(delegate.getRealm());
+
+		this.delegateType = delegateType;
+
+		setDelegate(delegate);
+	}
+
+	DelegatingObservable(Realm realm, Class<T> delegateType) {
+		super(realm);
+
+		this.delegateType = delegateType;
+	}
+
+	/**
+	 * Wraps an {@code observable} in a delegator, returning an {@link IDelegatingObservable} of the appropriate kind.
+	 *
+	 * @param observable
+	 *            an observable to wrap in a delegator
+	 * @return the delegator, which will be an instance of the {@link IDelegatingObservable} interface
+	 *
+	 * @throws IllegalArgumentException
+	 *             if the {@code observable} is of a kind for which no delegator is currently implemented
+	 */
+	public static IObservable wrap(IObservable observable) {
+		IObservable result;
+
+		if (Proxy.isProxyClass(observable.getClass()) && (Proxy.getInvocationHandler(observable) instanceof DelegatingInvocationHandler)) {
+			// Already have a delegator and it's a dynamic proxy. Just create another like it
+			try {
+				result = DelegatingInvocationHandler.wrapDynamicProxy(observable);
+			} catch (Exception e) {
+				// Seems unlikely as I must have created the observable in the first place
+				throw new IllegalArgumentException("observable is an invalid implementation of IDelegatingObservable", e); //$NON-NLS-1$
+			}
+		} else if (observable instanceof IObservableList) {
+			result = DelegatingObservableList.wrap((IObservableList) observable);
+		} else if (observable instanceof IObservableSet) {
+			result = DelegatingObservableSet.wrap((IObservableSet) observable);
+		} else if (observable instanceof IObservableValue) {
+			result = DelegatingObservableValue.wrap((IObservableValue) observable);
+		} else {
+			throw new IllegalArgumentException("no delegating wrapper implementation available for observable"); //$NON-NLS-1$
+		}
+
+		return result;
+	}
+
+	/**
+	 * Creates a new empty delegator suitable for observables of the specified type without any other mix-in interfaces such as {@link IObserving}.
+	 * Observable types must be specified by their abstract interface, and currently the following types are supported:
+	 * <ul>
+	 * <li>{@link IObservableValue}</li>
+	 * <li>{@link IObservableList}</li>
+	 * <li>{@link IObservableSet}</li>
+	 * </ul>
+	 *
+	 * @param observableType
+	 *            the kind of observable that will be the new delegator's delegate
+	 * @return the delegator, which will be an instance of the {@link IDelegatingObservable} interface
+	 *
+	 * @throws IllegalArgumentException
+	 *             if the {@code observable} is of a kind for which no delegator is currently implemented
+	 *
+	 * @see #create(Realm, Class, ClassLoader, Class...)
+	 */
+	public static <T extends IObservable> T create(Realm realm, Class<T> observableType) {
+		return create(realm, observableType, null); // Class loader not needed without any mix-ins
+	}
+
+	/**
+	 * Creates a new empty delegator suitable for observables of the specified type with optional mix-in interfaces such as {@link IObserving},
+	 * which is implemented by detail observables in a master/detail relationship. Observable types must be specified
+	 * by their abstract interface, and currently the following types are supported:
+	 * <ul>
+	 * <li>{@link IObservableValue}</li>
+	 * <li>{@link IObservableList}</li>
+	 * <li>{@link IObservableSet}</li>
+	 * </ul>
+	 *
+	 * @param observableType
+	 *            the kind of observable that will be the new delegator's delegate
+	 * @param loader
+	 *            a class loader that can see all of the {@code mixins}, if any
+	 * @param mixins
+	 *            optional mix-in interfaces that the resulting observable should refer to its delegate. These must all have {@linkplain #registerMixinHandler handlers already registered}
+	 * @return the delegator, which will be an instance of the {@link IDelegatingObservable} interface
+	 *
+	 * @throws IllegalArgumentException
+	 *             if the {@code observable} is of a kind for which no delegator is currently implemented
+	 */
+	@SuppressWarnings("unchecked")
+	public static <T extends IObservable> T create(Realm realm, Class<T> observableType, ClassLoader loader, Class<?>... mixins) {
+		if (observableType == IObservableList.class) {
+			return (T) DelegatingObservableList.create(realm, loader, mixins);
+		} else if (observableType == IObservableSet.class) {
+			return (T) DelegatingObservableSet.create(realm, loader, mixins);
+		} else if (observableType == IObservableValue.class) {
+			return (T) DelegatingObservableValue.create(realm, loader, mixins);
+		} else {
+			throw new IllegalArgumentException("observableType"); //$NON-NLS-1$
+		}
+	}
+
+	public final void setDelegate(final IObservable delegate) {
+		if (isDisposed()) {
+			throw new IllegalStateException("disposed"); //$NON-NLS-1$
+		}
+
+		final T oldDelegate = this.delegate;
+
+		if (delegate != oldDelegate) {
+			final T newDelegate = (delegate == null) ? null : delegateType.cast(delegate);
+
+			if (oldDelegate != null) {
+				unhookDelegate(oldDelegate);
+
+				// Release it only after this iteration of the event loop so that UI refreshes can still access it for now
+				// in case its retain count will go to zero and it will be disposed
+				ReferenceCountedObservable.Util.autorelease(oldDelegate);
+			}
+
+			this.delegate = newDelegate;
+
+			if (newDelegate != null) {
+				ReferenceCountedObservable.Util.retain(newDelegate);
+				hookDelegate(newDelegate);
+			}
+
+			delegateChanged(oldDelegate, newDelegate);
+		}
+	}
+
+	final void clearDelegate() {
+		// Can do this even if disposed
+
+		if (delegate != null) {
+			unhookDelegate(delegate);
+
+			delegate = null;
+
+			// Let listeners know that we've changed. We cannot fire an accurate value change event
+			// because we can no longer access the old delegate's value, as it is now disposed
+			fireChange();
+		}
+	}
+
+	public final T getDelegate() {
+		return delegate;
+	}
+
+	/**
+	 * Notifies of a change from one delegate to another. Subclasses overriding this must call {@code super}.
+	 *
+	 * @param oldDelegate
+	 *            the previous delegate, or {@code null} if there was none
+	 * @param newDelegate
+	 *            the new delegate, or {@code null} if now I have none
+	 */
+	protected void delegateChanged(T oldDelegate, T newDelegate) {
+		fireChange();
+	}
+
+	protected void hookDelegate(T delegate) {
+		delegate.addChangeListener(getForwardingChangeListener());
+		delegate.addStaleListener(getForwardingStaleListener());
+
+		// Don't forward dispose events because the delegate has its own lifecycle. However, when our delegate
+		// is disposed, we forget about it
+		delegate.addDisposeListener(getDelegateDisposeListener());
+	}
+
+	protected void unhookDelegate(T delegate) {
+		delegate.removeChangeListener(getForwardingChangeListener());
+		delegate.removeStaleListener(getForwardingStaleListener());
+		delegate.removeDisposeListener(getDelegateDisposeListener());
+	}
+
+	public boolean isStale() {
+		getterCalled();
+
+		return (delegate != null) && delegate.isStale();
+	}
+
+	protected void getterCalled() {
+		ObservableTracker.getterCalled(getRealObservable());
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		return (obj == this) || ((delegate == null) ? false : delegate.equals(obj));
+	}
+
+	@Override
+	public int hashCode() {
+		return (delegate == null) ? 0 : delegate.hashCode();
+	}
+
+	/**
+	 * Sets the real observable (which may be a dynamic proxy) to report as the source of events and the target of getter calls in the {@link ObservableTracker}.
+	 *
+	 * @param realObservable
+	 *            my event source
+	 */
+	final void setRealObservable(T realObservable) {
+		this.realObservable = realObservable;
+	}
+
+	/**
+	 * Gets the source to report for events (which may be a dynamic proxy).
+	 *
+	 * @return my event source
+	 */
+	final T getRealObservable() {
+		return realObservable;
+	}
+
+	@Override
+	protected final void fireChange() {
+		fireEvent(new ChangeEvent(getRealObservable()));
+	}
+
+	@Override
+	protected final void fireStale() {
+		fireEvent(new StaleEvent(getRealObservable()));
+	}
+
+	@Override
+	public void dispose() {
+		if (!isDisposed()) {
+			if (delegate != null) {
+				unhookDelegate(delegate);
+
+				// Release it only after this iteration of the event loop so that UI refreshes can still access it for now
+				// in case its retain count will go to zero and it will be disposed
+				ReferenceCountedObservable.Util.autorelease(delegate);
+				delegate = null;
+			}
+			super.dispose();
+		}
+	}
+
+	@Override
+	protected void fireEvent(ObservableEvent event) {
+		// ensure the correct source for events fired by the superclass
+		if ((event instanceof DisposeEvent) && (event.getSource() != getRealObservable())) {
+			event = new DisposeEvent(getRealObservable());
+		}
+
+		super.fireEvent(event);
+	}
+
+	private IChangeListener getForwardingChangeListener() {
+		if (forwardingChangeListener == null) {
+			forwardingChangeListener = new IChangeListener() {
+
+				public void handleChange(ChangeEvent event) {
+					DelegatingObservable.this.fireChange();
+				}
+			};
+		}
+
+		return forwardingChangeListener;
+	}
+
+	private IStaleListener getForwardingStaleListener() {
+		if (forwardingStaleListener == null) {
+			forwardingStaleListener = new IStaleListener() {
+
+				public void handleStale(StaleEvent staleEvent) {
+					DelegatingObservable.this.fireStale();
+				}
+			};
+		}
+
+		return forwardingStaleListener;
+	}
+
+	private IDisposeListener getDelegateDisposeListener() {
+		if (delegateDisposeListener == null) {
+			delegateDisposeListener = new IDisposeListener() {
+
+				public void handleDispose(DisposeEvent event) {
+					if (event.getObservable() == getDelegate()) {
+						clearDelegate();
+					}
+				}
+			};
+		}
+
+		return delegateDisposeListener;
+	}
+}