| //------------------------------------------------------------------------------ |
| // 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.authoring.ui.providers; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.emf.common.notify.AdapterFactory; |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.edit.provider.ITreeItemContentProvider; |
| import org.eclipse.emf.edit.provider.IViewerNotification; |
| import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider; |
| import org.eclipse.epf.library.edit.FeatureValueWrapperItemProvider; |
| import org.eclipse.epf.library.edit.TransientGroupItemProvider; |
| import org.eclipse.epf.library.edit.category.CustomCategoryItemProvider; |
| import org.eclipse.epf.library.edit.category.DisciplineCategoriesItemProvider; |
| import org.eclipse.epf.library.edit.category.DomainsItemProvider; |
| import org.eclipse.epf.library.edit.category.RoleSetsItemProvider; |
| import org.eclipse.epf.library.edit.category.ToolsItemProvider; |
| import org.eclipse.epf.library.edit.category.WorkProductTypesItemProvider; |
| import org.eclipse.epf.library.edit.navigator.ConfigurationsItemProvider; |
| import org.eclipse.epf.library.edit.navigator.PluginUIPackagesItemProvider; |
| import org.eclipse.epf.library.edit.util.TngUtil; |
| import org.eclipse.epf.library.services.SafeUpdateController; |
| import org.eclipse.epf.uma.ContentCategory; |
| import org.eclipse.epf.uma.CustomCategory; |
| import org.eclipse.epf.uma.MethodConfiguration; |
| import org.eclipse.epf.uma.MethodLibrary; |
| import org.eclipse.epf.uma.MethodPlugin; |
| import org.eclipse.jface.viewers.CheckboxTreeViewer; |
| import org.eclipse.jface.viewers.Viewer; |
| |
| /** |
| * Content provider for Custom Category view of configuration page |
| * |
| * @author Jeff Hardy |
| */ |
| |
| public class CategoryContentProvider extends AdapterFactoryContentProvider { |
| |
| // there is a problem in the passed in AdapterFactory |
| // it can't find the correct parent from the child |
| // need to build a map of child to it's parent if the child is a UI |
| // folder |
| // clear the map when the input is set |
| private Map<Object, Object> childUIParentMap = new HashMap<Object, Object>(); |
| |
| private MethodConfiguration config; |
| |
| /** |
| * Create an instance |
| * @param adapterFactory |
| */ |
| public CategoryContentProvider(AdapterFactory adapterFactory, MethodConfiguration config) { |
| super(adapterFactory); |
| this.config = config; |
| } |
| |
| /** |
| * @see org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider#getChildren(java.lang.Object) |
| */ |
| public Object[] getChildren(Object parentElement) { |
| Collection<Object> children = new ArrayList<Object>(); |
| if (parentElement instanceof MethodPlugin) { |
| // add standard categories UI folders as appropriate |
| DisciplineCategoriesItemProvider disciplines = (DisciplineCategoriesItemProvider)TngUtil.getDisciplineCategoriesItemProvider((MethodPlugin)parentElement); |
| if (disciplines != null && !disciplines.getChildren(disciplines).isEmpty()) { |
| children.add(disciplines); |
| } |
| DomainsItemProvider domains = (DomainsItemProvider)TngUtil.getDomainsItemProvider((MethodPlugin)parentElement); |
| if (domains != null && !domains.getChildren(domains).isEmpty()) { |
| children.add(domains); |
| } |
| WorkProductTypesItemProvider wpTypes = (WorkProductTypesItemProvider)TngUtil.getWorkProductTypesItemProvider((MethodPlugin)parentElement); |
| if (wpTypes != null && !wpTypes.getChildren(wpTypes).isEmpty()) { |
| children.add(wpTypes); |
| } |
| RoleSetsItemProvider roleSets = (RoleSetsItemProvider)TngUtil.getRoleSetsItemProvider((MethodPlugin)parentElement); |
| if (roleSets != null && !roleSets.getChildren(roleSets).isEmpty()) { |
| children.add(roleSets); |
| } |
| ToolsItemProvider tools = (ToolsItemProvider)TngUtil.getToolsItemProvider((MethodPlugin)parentElement); |
| if (tools != null && !tools.getChildren(tools).isEmpty()) { |
| children.add(tools); |
| } |
| |
| // add CustomCategories provider |
| // get root CC of plugin |
| CustomCategory rootCC = (TngUtil.getRootCustomCategory((MethodPlugin)parentElement)); |
| if (rootCC != null && !rootCC.getCategorizedElements().isEmpty()) { |
| children.add(rootCC); |
| } |
| // children = unwrapFVWIPs(children); |
| // children = filterCategoryElements(parentElement, children); |
| } else if (parentElement instanceof PluginUIPackagesItemProvider) { |
| children.addAll(Arrays.asList(super.getChildren(parentElement))); |
| children = filterPlugin(children); |
| } else if (parentElement instanceof ContentCategory) { |
| children.addAll(Arrays.asList(super.getChildren(parentElement))); |
| // children = unwrapFVWIPs(children); |
| children = filterCategoryElements(parentElement, children); |
| } else if (parentElement instanceof FeatureValueWrapperItemProvider) { |
| children.addAll(Arrays.asList(super.getChildren(parentElement))); |
| // children = unwrapFVWIPs(children); |
| children = filterCategoryElements(parentElement, children); |
| } else if (parentElement instanceof MethodLibrary) { |
| children.addAll(Arrays.asList(super.getElements(parentElement))); |
| children = filterPlugin(children); |
| } else if (parentElement instanceof TransientGroupItemProvider) { |
| children.addAll(Arrays.asList(super.getChildren(parentElement))); |
| } |
| createChildParentMap(parentElement, children); |
| return children.toArray(); |
| } |
| |
| private void createChildParentMap(Object parent, Collection children) { |
| if (children == null || children.size() == 0) { |
| return; |
| } |
| for (Iterator iter = children.iterator();iter.hasNext();) { |
| Object child = iter.next(); |
| // if the parent is a UI folder, map the child to the parent |
| // so that we can get the parent later |
| // if ( !(parent instanceof MethodElement) ) |
| { |
| childUIParentMap.put(child, parent); |
| } |
| } |
| } |
| |
| /** |
| * @see org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider#getElements(java.lang.Object) |
| */ |
| public Object[] getElements(Object inputElement) { |
| return getChildren(inputElement); |
| } |
| |
| private Collection<Object> filterPlugin(Collection<Object> elements) { |
| for (Iterator iter = elements.iterator();iter.hasNext();) { |
| Object element = iter.next(); |
| if (element instanceof MethodPlugin) { |
| // filter out plugins that have no CC's |
| if (!hasChildren((MethodPlugin)element) || !config.getMethodPluginSelection().contains(element)) { |
| iter.remove(); |
| } |
| } else if (element instanceof PluginUIPackagesItemProvider) { |
| // filter out plugin packages that have no plugins with CC's |
| if (!hasChildren((PluginUIPackagesItemProvider)element)) { |
| iter.remove(); |
| } |
| } else if (element instanceof ConfigurationsItemProvider) { |
| // remove "Configurations" folder |
| iter.remove(); |
| } |
| } |
| return elements; |
| } |
| |
| private Collection<Object> filterCategoryElements(Object parent, Collection<Object> elements) { |
| for (Iterator iter = elements.iterator();iter.hasNext();) { |
| Object element = iter.next(); |
| element = TngUtil.unwrap(element); |
| if (!(element instanceof ContentCategory)) { |
| // remove non-ContentCategory |
| iter.remove(); |
| } |
| } |
| return elements; |
| } |
| |
| // private Collection<Object> unwrapFVWIPs(Collection<Object> elements) { |
| // Collection<Object> result = new ArrayList<Object>(); |
| // for (Iterator iter = elements.iterator();iter.hasNext();) { |
| // Object element = iter.next(); |
| // element = TngUtil.unwrap(element); |
| // if (element instanceof CustomCategory) { |
| // result.add(getFirstTreeItemForCC((CustomCategory)element)); |
| // } else if (element instanceof ContentCategory) { |
| // result.add(element); |
| // } else if (element instanceof TransientCategoryPackageItemProvider) { |
| // result.add(element); |
| // } |
| // } |
| // return result; |
| // } |
| |
| /** |
| * @see org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider#getParent(java.lang.Object) |
| */ |
| public Object getParent(Object element) { |
| if (childUIParentMap.containsKey(element)) { |
| return childUIParentMap.get(element); |
| } else { |
| return null; |
| // try to determine parent |
| // Object parent = super.getParent(element); |
| // if (parent instanceof ContentPackage && |
| // element instanceof ContentCategory) { |
| // return LibraryUtil.getMethodPlugin((ContentCategory)element); |
| // } else if (parent instanceof CustomCategory) { |
| // parent = getFirstTreeItemForCC((CustomCategory)parent); |
| // } |
| // else if (parent instanceof FeatureValueWrapperItemProvider) { |
| // parent = TngUtil.unwrap(parent); |
| // } |
| // return parent; |
| } |
| } |
| |
| public Object getFirstTreeItemForCC(CustomCategory cc) { |
| // get ITreeContentProvider adapater |
| CustomCategoryItemProvider adapter = (CustomCategoryItemProvider) getAdapterFactory().adapt(cc, ITreeItemContentProvider.class); |
| for (Iterator iter = adapter.getNotifyChangedListeners().iterator(); iter.hasNext();) { |
| Object listener = iter.next(); |
| if (listener instanceof FeatureValueWrapperItemProvider |
| && TngUtil.unwrap(listener) == cc) { |
| return (FeatureValueWrapperItemProvider)listener; |
| } |
| } |
| return cc; |
| } |
| |
| public Collection<Object> getTreeItems(Object item) { |
| List<Object> result = new ArrayList<Object>(); |
| // get ITreeContentProvider adapater |
| List notifyChangedListeners = TngUtil.getNotifyChangedListeners(adapterFactory, item); |
| if (!notifyChangedListeners.isEmpty()) { |
| for (Iterator iterator = notifyChangedListeners.iterator(); iterator.hasNext();) { |
| Object listener = iterator.next(); |
| if(listener instanceof ITreeItemContentProvider |
| && TngUtil.unwrap(listener) == item) { |
| result.add(listener); |
| } |
| } |
| } else { |
| result.add(item); |
| } |
| return result; |
| } |
| |
| |
| /** |
| * @see org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider#hasChildren(java.lang.Object) |
| */ |
| public boolean hasChildren(Object element) { |
| Object[] children = getChildren(element); |
| return (children != null && children.length > 0); |
| } |
| |
| /** |
| * @see org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object) |
| */ |
| public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { |
| super.inputChanged(viewer, oldInput, newInput); |
| childUIParentMap.clear(); |
| } |
| |
| /** |
| * @see org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider#notifyChanged(org.eclipse.emf.common.notify.Notification) |
| */ |
| public void notifyChanged(Notification notification) { |
| super.notifyChanged(notification); |
| |
| if ((notification instanceof IViewerNotification)) { |
| final IViewerNotification vnt = (IViewerNotification) notification; |
| final Object element = vnt.getElement(); |
| final CheckboxTreeViewer ctrl = ((CheckboxTreeViewer) super.viewer); |
| if (element != null && (vnt.getEventType() == Notification.ADD |
| || vnt.getEventType() == Notification.SET)) { |
| |
| SafeUpdateController.syncExec(new Runnable() { |
| public void run() { |
| ctrl.refresh(); |
| } |
| }); |
| } |
| } |
| } |
| |
| /** |
| * @see org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider#dispose() |
| */ |
| public void dispose() { |
| super.dispose(); |
| childUIParentMap.clear(); |
| } |
| } |
