| //------------------------------------------------------------------------------ |
| // Copyright (c) 2005, 2007 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.navigator; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.emf.common.notify.AdapterFactory; |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.ecore.EStructuralFeature; |
| import org.eclipse.emf.edit.provider.IItemLabelProvider; |
| import org.eclipse.emf.edit.provider.IStructuredItemContentProvider; |
| import org.eclipse.emf.edit.provider.ITreeItemContentProvider; |
| import org.eclipse.emf.edit.provider.ItemProviderAdapter; |
| import org.eclipse.emf.edit.provider.ViewerNotification; |
| import org.eclipse.epf.library.edit.ILibraryItemProvider; |
| import org.eclipse.epf.library.edit.IStatefulItemProvider; |
| import org.eclipse.epf.library.edit.LibraryEditPlugin; |
| import org.eclipse.epf.library.edit.TngAdapterFactory; |
| import org.eclipse.epf.library.edit.util.Comparators; |
| import org.eclipse.epf.library.edit.util.PluginUIPackagesMap; |
| import org.eclipse.epf.library.edit.util.TngUtil; |
| import org.eclipse.epf.uma.MethodLibrary; |
| import org.eclipse.epf.uma.MethodPlugin; |
| import org.eclipse.epf.uma.UmaPackage; |
| import org.eclipse.epf.uma.provider.MethodPluginItemProvider; |
| |
| /** |
| * Item Provider Adapter that represents a plugin-package. This is a UI folder only |
| * @author Jeff Hardy |
| * |
| */ |
| public class PluginUIPackagesItemProvider extends ItemProviderAdapter implements IStructuredItemContentProvider, |
| ITreeItemContentProvider, IItemLabelProvider, ILibraryItemProvider, IStatefulItemProvider { |
| |
| public static final String PLUGIN_PACKAGE_SEPARATOR = "."; //$NON-NLS-1$ |
| |
| private Object parent; |
| |
| private String name; |
| |
| private Collection<MethodPlugin> plugins; |
| |
| private Map<String, PluginUIPackagesItemProvider> pluginPackagesItemProvidersMap = new HashMap<String, PluginUIPackagesItemProvider>(); |
| |
| |
| /** |
| * Creates a new instance. |
| */ |
| public PluginUIPackagesItemProvider(AdapterFactory adapterFactory, String packageName, Collection<MethodPlugin> plugins) { |
| super(adapterFactory); |
| this.name = packageName; |
| this.plugins = plugins; |
| } |
| |
| public void setParent(Object parent) { |
| this.parent = parent; |
| } |
| |
| /** |
| * |
| * @return the parent of this ItemProvider |
| */ |
| public Object getParent() { |
| return parent; |
| } |
| |
| @Override |
| public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) { |
| // TODO Auto-generated method stub |
| return super.getChildrenFeatures(object); |
| } |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.emf.edit.provider.ItemProviderAdapter#getText(java.lang.Object) |
| */ |
| public String getText(Object object) { |
| return name; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.emf.edit.provider.ItemProviderAdapter#getImage(java.lang.Object) |
| */ |
| public Object getImage(Object object) { |
| return LibraryEditPlugin.INSTANCE.getImage("full/obj16/package_obj"); //$NON-NLS-1$ |
| } |
| |
| public static String getNameDelta(PluginUIPackagesItemProvider topObject, Object bottomObject) { |
| |
| String topName= topObject.getFullName(); |
| String bottomName = null; |
| if (bottomObject instanceof PluginUIPackagesItemProvider) { |
| bottomName = ((PluginUIPackagesItemProvider)bottomObject).getFullName(); |
| |
| } else if (bottomObject instanceof MethodPlugin) { |
| bottomName = ((MethodPlugin)bottomObject).getName(); |
| } |
| |
| if(bottomName == null || topName.equals(bottomName)) |
| return topName; |
| try { |
| String deltaname= bottomName.substring(topName.length()+1); |
| return deltaname; |
| } catch (StringIndexOutOfBoundsException e) { |
| return bottomName; |
| } |
| } |
| |
| |
| public Collection<Object> getChildren(Object parentElement) { |
| return addChildren(plugins); |
| } |
| |
| private Collection<Object> addChildren(Collection<MethodPlugin> plugins) { |
| List children = new ArrayList(); |
| PluginUIPackagesMap map = new PluginUIPackagesMap(); |
| for (Iterator<MethodPlugin> iter = plugins.iterator();iter.hasNext();) { |
| MethodPlugin plugin = iter.next(); |
| String deltaName = getNameDelta(this, plugin); |
| int dotIdx = deltaName.indexOf(PLUGIN_PACKAGE_SEPARATOR); |
| if (dotIdx != -1) { |
| map.add(deltaName.substring(0, dotIdx), plugin); |
| } else { |
| children.add(plugin); |
| Object adapter = adapterFactory.adapt(plugin, |
| ITreeItemContentProvider.class); |
| if (adapter instanceof ILibraryItemProvider) { |
| ((ILibraryItemProvider) adapter).setParent(this); |
| } |
| } |
| } |
| Collection<String> existingNames = new HashSet<String>(); |
| for (Iterator<Map.Entry<String, Set<MethodPlugin>>> iter = map.entrySet().iterator();iter.hasNext();) { |
| Map.Entry<String, Set<MethodPlugin>> entry = iter.next(); |
| String name = entry.getKey(); |
| Set<MethodPlugin> plugSet = entry.getValue(); |
| PluginUIPackagesItemProvider provider = pluginPackagesItemProvidersMap.get(getFullName() + PLUGIN_PACKAGE_SEPARATOR + name); |
| if (provider == null) { |
| provider = new PluginUIPackagesItemProvider(adapterFactory, name, plugSet); |
| pluginPackagesItemProvidersMap.put(getFullName() + PLUGIN_PACKAGE_SEPARATOR + name, provider); |
| } else { |
| provider.setPlugins(plugSet); |
| } |
| existingNames.add(getFullName() + PLUGIN_PACKAGE_SEPARATOR + name); |
| provider.setParent(this); |
| children.add(provider); |
| } |
| retainPluginPackagesItemProviders(existingNames); |
| Collections.sort(children, Comparators.PLUGINPACKAGE_COMPARATOR); |
| return children; |
| } |
| |
| /** |
| * |
| * @return full name of this package |
| */ |
| public String getFullName() { |
| String fullName = getName(); |
| Object parent = getParent(); |
| while (parent instanceof PluginUIPackagesItemProvider) { |
| fullName = ((PluginUIPackagesItemProvider)parent).getName() + PLUGIN_PACKAGE_SEPARATOR + fullName; |
| parent = ((PluginUIPackagesItemProvider)parent).getParent(); |
| } |
| return fullName; |
| |
| } |
| |
| public String getName() { |
| return name; |
| } |
| |
| @Override |
| public Object getParent(Object object) { |
| if (parent != null) |
| return parent; |
| return target; |
| } |
| |
| public void notifyChanged(Notification notification) { |
| updateChildren(notification); |
| |
| switch (notification.getFeatureID(MethodPlugin.class)) { |
| case UmaPackage.METHOD_PLUGIN__NAME: |
| fireNotifyChanged(new ViewerNotification(notification, notification |
| .getNotifier(), true, true)); |
| break; |
| } |
| |
| super.notifyChanged(notification); |
| } |
| |
| @Override |
| public void dispose() { |
| // remove this from the plugins' adapter list |
| if (pluginPackagesItemProvidersMap != null) { |
| pluginPackagesItemProvidersMap.clear(); |
| pluginPackagesItemProvidersMap = null; |
| } |
| super.dispose(); |
| } |
| |
| private void retainPluginPackagesItemProviders(Collection<String> names) { |
| for (Iterator<String> iter = pluginPackagesItemProvidersMap.keySet().iterator();iter.hasNext();) { |
| String keyName = iter.next(); |
| if (!names.contains(keyName)) { |
| PluginUIPackagesItemProvider provider = pluginPackagesItemProvidersMap.get(keyName); |
| if (provider != null) { |
| provider.dispose(); |
| } |
| iter.remove(); |
| } |
| } |
| } |
| |
| public Collection<MethodPlugin> getPlugins() { |
| return plugins; |
| } |
| |
| public void setPlugins(Collection<MethodPlugin> plugins) { |
| this.plugins = plugins; |
| } |
| |
| /** |
| * |
| * @param plugin |
| * @return the ItemProviderAdapter for the plugin - either a MethodPluginItemProvider or a PluginUIPackagesItemProvider. null if none found |
| */ |
| public ItemProviderAdapter getPluginItemProvider(MethodPlugin plugin) { |
| String deltaName = getNameDelta(this, plugin); |
| int dotIdx = deltaName.indexOf(PluginUIPackagesItemProvider.PLUGIN_PACKAGE_SEPARATOR); |
| if (dotIdx != -1) { |
| String packageProviderName = deltaName.substring(0, dotIdx); |
| if (pluginPackagesItemProvidersMap != null) { |
| PluginUIPackagesItemProvider provider = pluginPackagesItemProvidersMap.get(getFullName() + PLUGIN_PACKAGE_SEPARATOR + packageProviderName); |
| if (provider != null) { |
| return provider; |
| } |
| } |
| } else { |
| return (MethodPluginItemProvider) TngUtil |
| .getAdapter(plugin, MethodPluginItemProvider.class); |
| } |
| return null; |
| } |
| |
| /** |
| * |
| * @param itemName name of item to find |
| * @param lib MethodLibrary |
| * @return the MethodPlugin or PluginUIPackagesItemProvider with the specified name, or null if not found |
| */ |
| public static Object findPluginItemProvider(String itemName, MethodLibrary lib) { |
| ITreeItemContentProvider adapter = (ITreeItemContentProvider)TngAdapterFactory.INSTANCE |
| .getNavigatorView_ComposedAdapterFactory().adapt(lib, ITreeItemContentProvider.class); |
| if (adapter instanceof MethodLibraryItemProvider) { |
| MethodLibraryItemProvider libraryAdapter = (MethodLibraryItemProvider)adapter; |
| List<MethodPlugin> pluginList = lib.getMethodPlugins(); |
| for (MethodPlugin plugin : pluginList) { |
| if (itemName.equals(plugin.getName())) { |
| return plugin; |
| } |
| Collection<?> children = libraryAdapter.getChildren(lib); |
| ItemProviderAdapter pluginTreeAdapter = libraryAdapter.getPluginItemProvider(plugin); |
| while (pluginTreeAdapter instanceof PluginUIPackagesItemProvider) { |
| if (itemName.equals(((PluginUIPackagesItemProvider)pluginTreeAdapter).getFullName())) { |
| return pluginTreeAdapter; |
| } |
| children = pluginTreeAdapter.getChildren(pluginTreeAdapter); |
| pluginTreeAdapter = ((PluginUIPackagesItemProvider)pluginTreeAdapter).getPluginItemProvider(plugin); |
| } |
| } |
| } |
| return null; |
| } |
| } |