| //------------------------------------------------------------------------------ |
| // Copyright (c) 2005, 2006 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 implementation |
| //------------------------------------------------------------------------------ |
| package org.eclipse.epf.library.edit.process; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.emf.common.command.Command; |
| import org.eclipse.emf.common.notify.AdapterFactory; |
| import org.eclipse.emf.common.util.UniqueEList; |
| import org.eclipse.emf.edit.domain.EditingDomain; |
| import org.eclipse.emf.edit.provider.Disposable; |
| import org.eclipse.emf.edit.provider.ITreeItemContentProvider; |
| import org.eclipse.emf.edit.provider.IWrapperItemProvider; |
| import org.eclipse.epf.library.edit.LibraryEditPlugin; |
| import org.eclipse.epf.library.edit.command.IResourceAwareCommand; |
| import org.eclipse.epf.library.edit.process.command.OBSDragAndDropCommand; |
| import org.eclipse.epf.library.edit.process.command.OBSDropCommand; |
| import org.eclipse.epf.library.edit.util.Comparators; |
| import org.eclipse.epf.library.edit.util.ProcessUtil; |
| import org.eclipse.epf.library.edit.util.TngUtil; |
| import org.eclipse.epf.uma.Activity; |
| import org.eclipse.epf.uma.Descriptor; |
| import org.eclipse.epf.uma.Milestone; |
| import org.eclipse.epf.uma.Role; |
| import org.eclipse.epf.uma.RoleDescriptor; |
| import org.eclipse.epf.uma.TeamProfile; |
| import org.eclipse.epf.uma.UmaFactory; |
| import org.eclipse.epf.uma.UmaPackage; |
| import org.eclipse.epf.uma.util.AssociationHelper; |
| |
| |
| /** |
| * Item provider for Team Allocation activity |
| * |
| * @author Phong Nguyen Le |
| * @author Shilpa Toraskar |
| * @since 1.0 |
| * |
| */ |
| public class OBSActivityItemProvider extends BSActivityItemProvider { |
| |
| private Disposable rolledUpWrappers; |
| |
| /** |
| * @param adapterFactory |
| */ |
| public OBSActivityItemProvider(AdapterFactory adapterFactory) { |
| super(adapterFactory); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.ibm.library.edit.process.BSActivityItemProvider#collectNewChildDescriptors(java.util.Collection, |
| * java.lang.Object) |
| */ |
| protected void collectNewChildDescriptors(Collection newChildDescriptors, |
| Object object) { |
| // Activity act = (Activity) object; |
| // if(hasChildDescriptor(act)) { |
| // newChildDescriptors.add |
| // (createChildParameter |
| // (UmaPackage.eINSTANCE.getActivity_BreakdownElements(), |
| // UmaFactory.eINSTANCE.createRoleDescriptor())); |
| // |
| // newChildDescriptors.add |
| // (createChildParameter |
| // (UmaPackage.eINSTANCE.getActivity_BreakdownElements(), |
| // UmaFactory.eINSTANCE.createTeamProfile())); |
| // |
| // } |
| // else { |
| newChildDescriptors.add(createChildParameter(UmaPackage.eINSTANCE |
| .getActivity_BreakdownElements(), UmaFactory.eINSTANCE |
| .createPhase())); |
| |
| newChildDescriptors.add(createChildParameter(UmaPackage.eINSTANCE |
| .getActivity_BreakdownElements(), UmaFactory.eINSTANCE |
| .createIteration())); |
| |
| newChildDescriptors.add(createChildParameter(UmaPackage.eINSTANCE |
| .getActivity_BreakdownElements(), UmaFactory.eINSTANCE |
| .createActivity())); |
| |
| // if(act.getBreakdownElements().isEmpty()) { |
| newChildDescriptors.add(createChildParameter(UmaPackage.eINSTANCE |
| .getActivity_BreakdownElements(), UmaFactory.eINSTANCE |
| .createRoleDescriptor())); |
| |
| // COMPOSITE ROLE FEATURE IS NOT AVAILABLE FOR FIRST RELEASE. |
| // newChildDescriptors.add |
| // (createChildParameter |
| // (UmaPackage.eINSTANCE.getActivity_BreakdownElements(), |
| // UmaFactory.eINSTANCE.createCompositeRole())); |
| // |
| newChildDescriptors.add(createChildParameter(UmaPackage.eINSTANCE |
| .getActivity_BreakdownElements(), UmaFactory.eINSTANCE |
| .createTeamProfile())); |
| |
| // } |
| // } |
| |
| newChildDescriptors.add(createChildParameter(UmaPackage.eINSTANCE |
| .getActivity_BreakdownElements(), UmaFactory.eINSTANCE |
| .createMilestone())); |
| |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.epf.uma.tng.process.BSActivityItemProvider#acceptAsChild(java.lang.Object) |
| */ |
| protected boolean acceptAsChild(Object child) { |
| child = TngUtil.unwrap(child); |
| |
| if (child instanceof Activity || child instanceof RoleDescriptor |
| || child instanceof TeamProfile || child instanceof Milestone) { |
| return super.acceptAsChild(child); |
| } |
| return false; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.ibm.library.edit.process.BSActivityItemProvider#getObject(org.eclipse.epf.uma.Descriptor) |
| */ |
| protected Object getObject(Descriptor descriptor) { |
| try { |
| return ((RoleDescriptor) descriptor).getRole(); |
| } |
| catch(ClassCastException e) { |
| LibraryEditPlugin.getDefault().getLogger().logError(e); |
| throw e; |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.ibm.library.edit.process.BSActivityItemProvider#createDropCommand(java.lang.Object, |
| * java.util.List) |
| */ |
| public IResourceAwareCommand createDropCommand(Object owner, |
| List dropElements) { |
| return new OBSDropCommand((Activity) owner, dropElements); |
| } |
| |
| protected Command createDragAndDropCommand(EditingDomain domain, |
| Object owner, float location, int operations, int operation, |
| Collection collection) { |
| // System.out |
| // .println("ENTER: |
| // com.ibm.library.edit.process.WBSActivityItemProvider#createDragAndDropCommand(domain, |
| // owner, location, operations, operation, collection)"); |
| Command cmd = new OBSDragAndDropCommand(domain, owner, location, |
| operations, operation, collection); |
| |
| // System.out.println(" can execute: " + cmd.canExecute()); |
| // System.out.println(" owner: " + owner); |
| // System.out.println(" collection: " + collection); |
| // System.out.println(" location: " + location); |
| // System.out.println(" operations: " + operations); |
| // System.out.println(" operation: " + operation); |
| // |
| // System.out |
| // .println("EXIT: |
| // com.ibm.library.edit.process.WBSActivityItemProvider#createDragAndDropCommand(domain, |
| // owner, location, operations, operation, collection)"); |
| return cmd; |
| } |
| |
| // /* (non-Javadoc) |
| // * @see |
| // com.ibm.library.edit.process.BSActivityItemProvider#refreshChildren(org.eclipse.emf.common.notify.Notification, |
| // java.util.List) |
| // */ |
| // protected void refreshChildren(Notification notification, List |
| // newOrOldChildren) { |
| // if(!newOrOldChildren.isEmpty()) { |
| // Process topAct = (Process) getTopItem(); |
| // AdapterFactory rootAdapterFactory = getRootAdapterFactory(); |
| // |
| // ProcessUtil.refreshViewer(rootAdapterFactory, topAct); |
| // |
| // return; |
| // |
| // } |
| // } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.epf.library.edit.process.BSActivityItemProvider#isNewDescriptor(java.util.List, java.lang.Object) |
| */ |
| protected boolean isNewDescriptor(List children, Object child) { |
| Object obj = TngUtil.unwrap(child); |
| // collect all role descriptors or their wrappers first for matching with team profiles |
| // and eliminate the duplicates later in getChildren() |
| // |
| if(obj instanceof RoleDescriptor) { |
| return true; |
| } |
| return super.isNewDescriptor(children, obj); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.ibm.library.edit.process.BSActivityItemProvider#getChildren(java.lang.Object) |
| */ |
| public Collection getChildren(Object object) { |
| if (rolledUpWrappers != null) { |
| rolledUpWrappers.dispose(); |
| } |
| |
| if (isRolledUp()) { |
| List teamProfiles = new ArrayList(); |
| List roleDescriptors = new ArrayList(); |
| HashSet roleTeamPairs = new HashSet(); |
| HashSet roleDescriptorsWithoutLinkedElements = new HashSet(); |
| Collection children = super.getChildren(object); |
| |
| // collect all team profiles under this activity |
| // |
| HashSet validTeamProfiles = new HashSet(); |
| for (Iterator iter = children.iterator(); iter.hasNext();) { |
| Object o = iter.next(); |
| Object e = TngUtil.unwrap(o); |
| if (e instanceof TeamProfile) { |
| if(validTeamProfiles.add(e)) { |
| teamProfiles.add(o); |
| } |
| } |
| } |
| |
| for (Iterator iter = children.iterator(); iter.hasNext();) { |
| Object child = iter.next(); |
| Object e = TngUtil.unwrap(child); |
| if (e instanceof RoleDescriptor) { |
| RoleDescriptor desc = (RoleDescriptor) e; |
| List list; |
| List descriptors = null; |
| ComposedBreakdownElementWrapperItemProvider composedWrapper = null; |
| if(child instanceof RoleDescriptorWrapperItemProvider) { |
| Object value = ((RoleDescriptorWrapperItemProvider)child).getValue(); |
| if(value instanceof ComposedBreakdownElementWrapperItemProvider) { |
| composedWrapper = (ComposedBreakdownElementWrapperItemProvider) value; |
| } |
| } |
| if(composedWrapper != null) { |
| list = new UniqueEList(); |
| descriptors = new ArrayList(); |
| for (Iterator iterator = composedWrapper.getValues().iterator(); iterator |
| .hasNext();) { |
| Object o = iterator.next(); |
| Object element = TngUtil.unwrap(o); |
| if(element instanceof RoleDescriptor) { |
| List teams = AssociationHelper.getTeamProfiles((RoleDescriptor) element); |
| for (Iterator itor = teams.iterator(); itor |
| .hasNext();) { |
| Object team = itor.next(); |
| if(list.add(team)) { |
| descriptors.add(o); |
| } |
| |
| } |
| } |
| } |
| } |
| else { |
| list = AssociationHelper.getTeamProfiles(desc); |
| } |
| int size = list.size(); |
| if(size > 1) { |
| if (rolledUpWrappers == null) { |
| rolledUpWrappers = new Disposable(); |
| } |
| |
| boolean readOnly = false; |
| if (child instanceof BreakdownElementWrapperItemProvider) { |
| readOnly = ((BreakdownElementWrapperItemProvider) child) |
| .isReadOnly(); |
| } |
| |
| // show one descriptor per team |
| // |
| for (int i = 0; i < size; i++) { |
| TeamRoleDescriptorItemProvider itemProvider = new TeamRoleDescriptorItemProvider( |
| descriptors.get(i), object, adapterFactory); |
| itemProvider.readOnly = readOnly; |
| TeamProfile team = (TeamProfile) list.get(i); |
| |
| // // add team to the team list only if the team is under this activity |
| // // |
| // if(validTeamProfiles.contains(team)) { |
| // addTeamProfiles(object, teamProfiles, team); |
| // } |
| |
| itemProvider.team = team; |
| rolledUpWrappers.add(itemProvider); |
| roleDescriptors.add(itemProvider); |
| roleTeamPairs.add(new RoleTeamPair((Role) getObject(desc), team)); |
| } |
| } |
| else { |
| Role role = (Role) getObject(desc); |
| TeamProfile team = (TeamProfile) (size == 1 ? list.get(0) : null); |
| if(role == null) { |
| if(!roleDescriptorsWithoutLinkedElements.contains(e)) { |
| roleDescriptors.add(child); |
| |
| // // add team to the team list only if the team is under this activity |
| // // |
| // if(team != null && validTeamProfiles.contains(team)) { |
| // addTeamProfiles(object, teamProfiles, team); |
| // } |
| |
| roleDescriptorsWithoutLinkedElements.add(e); |
| } |
| } |
| else { |
| RoleTeamPair roleTeamPair = new RoleTeamPair(role, team); |
| if(!roleTeamPairs.contains(roleTeamPair)) { |
| roleDescriptors.add(child); |
| |
| // // add team to the team list only if the team is under this activity |
| // // |
| // if(team != null && validTeamProfiles.contains(team)) { |
| // addTeamProfiles(object, teamProfiles, team); |
| // } |
| |
| roleTeamPairs.add(roleTeamPair); |
| } |
| } |
| } |
| } |
| } |
| roleTeamPairs.clear(); |
| roleTeamPairs = null; |
| Collections.sort(teamProfiles, Comparators.PRESENTATION_NAME_COMPARATOR); |
| Collections.sort(roleDescriptors, Comparators.PRESENTATION_NAME_COMPARATOR); |
| children = new ArrayList(teamProfiles); |
| children.addAll(roleDescriptors); |
| |
| updateCachedChildren(children); |
| |
| return children; |
| } |
| Collection children = super.getChildren(object); |
| updateCachedChildren(children); |
| return children; |
| } |
| |
| public Collection getEClasses() { |
| return ProcessUtil.getOBSEclasses(); |
| } |
| |
| private void addTeamProfiles(Object owner, Collection teamProfiles, TeamProfile teamProfile) { |
| if (!TngUtil.checkExist(teamProfiles, teamProfile)) { |
| TeamProfileWrapperItemProvider wrapper = new TeamProfileWrapperItemProvider( |
| teamProfile, owner, adapterFactory) { |
| /* (non-Javadoc) |
| * @see org.eclipse.emf.edit.provider.DelegatingWrapperItemProvider#getChildren(java.lang.Object) |
| */ |
| public Collection getChildren(Object object) { |
| Collection children = super.getChildren(object); |
| |
| // // don't show role descriptors |
| // // |
| // for (Iterator iter = children.iterator(); iter.hasNext();) { |
| // Object child = TngUtil.unwrap(iter.next()); |
| // if(child instanceof RoleDescriptor) { |
| // iter.remove(); |
| // } |
| // } |
| |
| return children; |
| } |
| |
| }; |
| IBSItemProvider adapter = (IBSItemProvider) adapterFactory |
| .adapt(teamProfile, |
| ITreeItemContentProvider.class); |
| wrapper.readOnly = (getTopItem() != adapter.getTopItem()); |
| teamProfiles.add(wrapper); |
| } |
| } |
| |
| private static class TeamRoleDescriptorItemProvider extends |
| RoleDescriptorWrapperItemProvider { |
| |
| |
| public TeamRoleDescriptorItemProvider(Object value, Object owner, AdapterFactory adapterFactory) { |
| super(value, owner, adapterFactory); |
| } |
| |
| /** |
| * @param value |
| * @param owner |
| * @param adapterFactory |
| */ |
| public TeamRoleDescriptorItemProvider(RoleDescriptor value, |
| Object owner, AdapterFactory adapterFactory) { |
| super(value, owner, adapterFactory); |
| readOnly = false; |
| } |
| |
| private TeamProfile team; |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.ibm.library.edit.process.RoleDescriptorItemProvider#getAttribute(java.lang.Object, |
| * java.lang.String) |
| */ |
| public String getAttribute(Object object, String property) { |
| if (property == IBSItemProvider.COL_TEAMS && team != null) { |
| return TngUtil.getPresentationName(team); |
| } |
| return super.getAttribute(object, property); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.ibm.library.edit.process.BreakdownElementWrapperItemProvider#createWrapper(java.lang.Object, |
| * java.lang.Object, org.eclipse.emf.common.notify.AdapterFactory) |
| */ |
| protected IWrapperItemProvider createWrapper(Object value, |
| Object owner, AdapterFactory adapterFactory) { |
| BreakdownElementWrapperItemProvider wrapper = (BreakdownElementWrapperItemProvider) super |
| .createWrapper(value, owner, adapterFactory); |
| wrapper.readOnly = readOnly; |
| return wrapper; |
| } |
| } |
| |
| private static class RoleTeamPair { |
| private Role role; |
| private TeamProfile team; |
| |
| RoleTeamPair(Role role, TeamProfile team) { |
| this.role = role; |
| this.team = team; |
| } |
| |
| public boolean equals(Object obj) { |
| if(obj == this) return true; |
| if(obj instanceof RoleTeamPair) { |
| RoleTeamPair other = (RoleTeamPair) obj; |
| return role == other.role && (team == other.team || (team == null && other.team == null)); |
| } |
| else { |
| return false; |
| } |
| } |
| |
| public int hashCode() { |
| String str = role.getGuid(); |
| if(team != null) { |
| str = str + team.getGuid(); |
| } |
| return str.hashCode(); |
| } |
| } |
| |
| @Override |
| protected boolean isWrappingRollupNeeded(Object object) { |
| if(TngUtil.unwrap(object) instanceof RoleDescriptor) { |
| return true; |
| } |
| return super.isWrappingRollupNeeded(object); |
| } |
| |
| @Override |
| protected Object createRollupWrapper(Object object, Object owner, AdapterFactory adapterFactory) { |
| Object wrapper = super.createRollupWrapper(object, owner, adapterFactory); |
| return new RoleDescriptorWrapperItemProvider(wrapper, owner, adapterFactory); |
| } |
| } |