| /******************************************************************************* |
| * 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) |
| */ |
| 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) |
| */ |
| 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)) |
| */ |
| 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(); |
| } |