/*******************************************************************************
* Copyright (c) 2003, 2005 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jst.j2ee.internal.ejb.provider;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.EcorePackage;
import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jst.j2ee.ejb.AssemblyDescriptor;
import org.eclipse.jst.j2ee.ejb.CMPAttribute;
import org.eclipse.jst.j2ee.ejb.EjbMethodElementComparator;
import org.eclipse.jst.j2ee.ejb.EnterpriseBean;
import org.eclipse.jst.j2ee.ejb.MethodElement;
import org.eclipse.jst.j2ee.ejb.internal.impl.EjbFactoryImpl;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.wst.common.frameworks.internal.ui.DisplayUtility;
public abstract class AbstractMethodsContentProvider extends AdapterFactoryContentProvider {
protected static EStructuralFeature ME_EJB_SF = EjbFactoryImpl.getPackage().getMethodElement_EnterpriseBean();
protected static EStructuralFeature JAR_ASSEMBLY_SF = EjbFactoryImpl.getPackage().getEJBJar_AssemblyDescriptor();
private static final EStructuralFeature ECORE_BEAN_NAME = EcorePackage.eINSTANCE.getENamedElement_Name(); //ENAMED_ELEMENT__NAME
protected Comparator meComparator;
protected boolean isRoot = true;
public class EJBMethodItem {
public EObject refObject;
public EnterpriseBean ejb;
public EJBMethodItem(EObject aRefObject, EnterpriseBean anEJB) {
refObject = aRefObject;
ejb = anEJB;
}
}
/**
* Constructor for AbstractMethodsContentProvider.
*
* @param adapterFactory
*/
public AbstractMethodsContentProvider(AdapterFactory adapterFactory) {
super(adapterFactory);
}
public AbstractMethodsContentProvider(AdapterFactory adapterFactory, boolean root) {
super(adapterFactory);
isRoot = root;
}
protected Comparator getEnterpriseBeanComparator() {
return EJBNameComparator.singleton();
}
protected Comparator getMethodElementComparator() {
if (meComparator == null)
meComparator = new EjbMethodElementComparator();
return meComparator;
}
/*
* @see ITreeContentProvider#getChildren(Object)
*/
@Override
public Object[] getChildren(Object parentElement) {
if (parentElement instanceof AbstractMethodsContentProvider.EJBMethodItem)
return getMethodElements((AbstractMethodsContentProvider.EJBMethodItem) parentElement);
return new Object[0];
}
protected Object[] getMethodElements(AbstractMethodsContentProvider.EJBMethodItem ejbItem) {
EObject refObject = ejbItem.refObject;
if (refObject == null)
return new Object[0];
List elements = getMethodElements(refObject, ejbItem.ejb);
Object[] result = elements.toArray();
if (result.length == 1)
return result;
Arrays.sort(result, getMethodElementComparator());
return result;
}
protected abstract List getMethodElements(EObject aRefObject, EnterpriseBean anEJB);
protected Object[] getEnterpriseBeans(EObject parentElement, List someMethodElements) {
if (someMethodElements.isEmpty())
return new Object[0];
Set ejbs = new HashSet();
EnterpriseBean ejb = null;
MethodElement me = null;
for (int i = 0; i < someMethodElements.size(); i++) {
me = (MethodElement) someMethodElements.get(i);
ejb = me.getEnterpriseBean();
if (ejb != null)
ejbs.add(ejb);
}
Object[] result = ejbs.toArray();
if (result.length != 1)
Arrays.sort(result, getEnterpriseBeanComparator());
ejb = null;
for (int i = 0; i < result.length; i++) {
ejb = (EnterpriseBean) result[i];
result[i] = new EJBMethodItem(parentElement, ejb);
}
return result;
}
protected AssemblyDescriptor getAssemblyDescriptor(EnterpriseBean ejb) {
if (ejb == null)
return null;
return ejb.getEjbJar().getAssemblyDescriptor();
}
/*
* @see ITreeContentProvider#hasChildren(Object)
*/
@Override
public boolean hasChildren(Object element) {
if (element instanceof AbstractMethodsContentProvider.EJBMethodItem)
return true;
return false;
}
protected TreeViewer getTreeViewer() {
return (TreeViewer) viewer;
}
protected void refreshTreeViewer(Object obj) {
if (viewer != null)
DisplayUtility.asyncExec(createRefreshTreeRunnable(obj));
}
protected void refreshTreeViewer() {
if (viewer != null)
DisplayUtility.asyncExec(createRefreshTreeRunnable(null));
}
protected void refreshTreeViewer(MethodElement me) {
refreshTreeViewer(me.eContainer());
}
protected void refreshTreeViewer(List aList) {
if (aList.isEmpty())
return;
refreshTreeViewer((MethodElement) aList.get(0));
}
protected void addToTreeViewer(final MethodElement me) {
if (viewer == null)
return;
DisplayUtility.asyncExec(new Runnable() {
/*
* (non-Javadoc)
*
* @see java.lang.Runnable#run()
*/
public void run() {
// findMethodItem() should be run in a Display thread
EJBMethodItem item = findMethodItem(me);
if (item != null)
DisplayUtility.asyncExec(createAddItemTreeRunnable(item, me));
else
refreshTreeViewer(me.eContainer());
}
});
}
protected void removeFromTreeViewer(final EObject parent, final MethodElement me) {
if (viewer == null)
return;
DisplayUtility.asyncExec(new Runnable() {
/*
* (non-Javadoc)
*
* @see java.lang.Runnable#run()
*/
public void run() {
EnterpriseBean ejb = me.getEnterpriseBean();
EJBMethodItem item = findMethodItem(ejb, parent);
if (item != null)
refreshTreeViewer(item);
else
refreshTreeViewer((Object) null);
}
});
}
protected EJBMethodItem findMethodItem(MethodElement me) {
return findMethodItem(me.getEnterpriseBean(), me.eContainer());
}
protected EJBMethodItem findMethodItem(EnterpriseBean ejb, EObject parentMethod) {
TreeItem[] items = getTreeViewer().getTree().getItems();
return findMethodItem(ejb, parentMethod, items);
}
protected EJBMethodItem findMethodItem(EnterpriseBean ejb, EObject parentMethod, TreeItem[] items) {
TreeItem item = null;
Object data = null;
EJBMethodItem methodItem = null, found = null;
for (int i = 0; i < items.length; i++) {
item = items[i];
data = item.getData();
if (data instanceof EJBMethodItem) {
methodItem = (EJBMethodItem) data;
if (methodItem.ejb == ejb && methodItem.refObject == parentMethod)
return methodItem;
}
found = findMethodItem(ejb, parentMethod, item.getItems());
if (found != null)
return found;
}
return null;
}
/*
* @see INotifyChangedListener#notifyChanged(new ENotificationImpl((InternalEObject)Object,
* int,(EStructuralFeature) Object, Object, Object, int))
*/
@Override
public void notifyChanged(Notification notifier) {
if (notifier.getEventType() == Notification.RESOLVE)
return;
else if (notifier.getOldValue() instanceof CMPAttribute && notifier.getNewValue() == null)
return;
else if (notifier.getFeature() == ME_EJB_SF) {
refreshTreeViewer((MethodElement) notifier.getNotifier());
return;
} else if (notifier.getFeature() == ECORE_BEAN_NAME) {
refreshTreeViewer();
return;
} else if (getMethodElementsReference() == notifier.getFeature()) {
if (notifier.getEventType() == Notification.ADD)
addToTreeViewer((MethodElement) notifier.getNewValue());
else if (notifier.getEventType() == Notification.REMOVE)
removeFromTreeViewer((EObject) notifier.getNotifier(), (MethodElement) notifier.getOldValue());
return;
} else if (notifier.getFeature() == JAR_ASSEMBLY_SF && isRoot) {
updateTreeInput(notifier.getNewValue());
} else if (notifier.getFeature() == getMethodElementsContainerReference())
super.notifyChanged(notifier);
}
/**
* @param notifier
*/
protected void updateTreeInput(final Object target) {
DisplayUtility.asyncExec(new Runnable() {
/*
* (non-Javadoc)
*
* @see java.lang.Runnable#run()
*/
public void run() {
getTreeViewer().setInput(target); //reset the input
getTreeViewer().refresh(target);
}
});
}
private Runnable createAddItemTreeRunnable(final Object parent, final MethodElement me) {
return new Runnable() {
/*
* (non-Javadoc)
*
* @see java.lang.Runnable#run()
*/
public void run() {
getTreeViewer().add(parent, me);
}
};
}
private Runnable createRefreshTreeRunnable(final Object target) {
return new Runnable() {
/*
* (non-Javadoc)
*
* @see java.lang.Runnable#run()
*/
public void run() {
if (target != null)
getTreeViewer().refresh(target);
else
getTreeViewer().refresh();
}
};
}
protected abstract EStructuralFeature getMethodElementsReference();
protected abstract EStructuralFeature getMethodElementsContainerReference();
}