| //------------------------------------------------------------------------------ |
| // 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.configuration; |
| |
| import java.util.ArrayList; |
| 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.util.EList; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider; |
| import org.eclipse.epf.library.events.ILibraryChangeListener; |
| import org.eclipse.epf.library.layout.ElementLayoutManager; |
| import org.eclipse.epf.library.services.DependencyManager; |
| import org.eclipse.epf.library.services.LibraryProcessor; |
| import org.eclipse.epf.uma.MethodConfiguration; |
| import org.eclipse.epf.uma.MethodLibrary; |
| import org.eclipse.epf.uma.MethodPlugin; |
| |
| |
| /** |
| * @author Jinhua Xi |
| * @sice 1.0 |
| */ |
| public class ConfigurationFactory { |
| |
| protected AdapterFactoryContentProvider afcp = null; |
| |
| // map of MethodConfiguration name to Coniguration object |
| private Map configMap = new HashMap(); |
| |
| private LibraryProcessor libraryProc = null; |
| |
| private String currentConfigName = null; |
| |
| // map of config name to layout manager |
| // each config has it's own layout manager |
| private Map layoutMgrMap = new HashMap(); |
| |
| private DependencyManager depMgr = null; |
| |
| public ConfigurationFactory(LibraryProcessor libraryProc) { |
| |
| this.libraryProc = libraryProc; |
| |
| afcp = new AdapterFactoryContentProvider(libraryProc |
| .getAdapterFactory()); |
| |
| libraryProc.addListener(new ILibraryChangeListener() { |
| public void libraryChanged(int option, Collection collection) { |
| if (option == ILibraryChangeListener.OPTION_CREATED |
| || option == ILibraryChangeListener.OPTION_LOADED) { |
| clear(); |
| } |
| } |
| |
| }); |
| |
| clear(); |
| } |
| |
| public void clear() { |
| currentConfigName = null; |
| if (configMap.size() > 0) { |
| for (Iterator it = configMap.values().iterator(); it.hasNext();) { |
| ((ConfigurationClosure) it.next()).dispose(); |
| } |
| } |
| configMap.clear(); |
| |
| if (layoutMgrMap.size() > 0) { |
| for (Iterator it = layoutMgrMap.values().iterator(); it.hasNext();) { |
| ((ElementLayoutManager) it.next()).clear(); |
| } |
| } |
| |
| layoutMgrMap.clear(); |
| |
| if (depMgr != null) { |
| depMgr.clear(); |
| depMgr = null; |
| } |
| } |
| |
| public MethodLibrary getLibrary() { |
| return libraryProc.getLibrary(); |
| } |
| |
| public URI getLibraryUri() { |
| return libraryProc.getLibraryURI(); |
| } |
| |
| public AdapterFactory getAdapterFactory() { |
| return libraryProc.getAdapterFactory(); |
| } |
| |
| public AdapterFactoryContentProvider getContentProvider() { |
| return afcp; |
| } |
| |
| public DependencyManager getDependencyManager() { |
| // return libraryProc.getDependencyManager(); |
| if (this.depMgr == null) { |
| depMgr = new DependencyManager(libraryProc); |
| } |
| |
| return depMgr; |
| } |
| |
| public List getMethodPlugins() { |
| List items = new ArrayList(); |
| EList elements = libraryProc.getLibrary().eContents(); |
| if (elements != null) { |
| for (Iterator it = elements.iterator(); it.hasNext();) { |
| EObject element = (EObject) it.next(); |
| if (element instanceof MethodPlugin) { |
| items.add(element); |
| } |
| } |
| } |
| |
| return items; |
| } |
| |
| public void setCurrentConfiguration(String configName) { |
| this.currentConfigName = configName; |
| } |
| |
| public String getCurrentConfiguration() { |
| return currentConfigName; |
| } |
| |
| public ElementLayoutManager getLayoutManager() { |
| return getLayoutManager(this.currentConfigName); |
| } |
| |
| public ElementLayoutManager getLayoutManager(String configName) { |
| ElementLayoutManager mgr = null; |
| if (configName == null) { |
| mgr = libraryProc.getLayoutManager(); |
| } else { |
| mgr = (ElementLayoutManager) layoutMgrMap.get(configName); |
| if (mgr == null) { |
| MethodConfiguration config = libraryProc |
| .getConfiguration(configName); |
| mgr = new ElementLayoutManager(config); |
| layoutMgrMap.put(configName, mgr); |
| } |
| } |
| |
| return mgr; |
| } |
| |
| public ConfigurationClosure getClosure() { |
| return getClosure(currentConfigName); |
| } |
| |
| public ConfigurationClosure getClosure(String configName) { |
| ConfigurationClosure config = null; |
| if (configName != null) { |
| config = (ConfigurationClosure) configMap.get(configName); |
| if (config == null) { |
| MethodConfiguration modelConfig = libraryProc |
| .getConfiguration(configName); |
| config = new ConfigurationClosure(this, modelConfig); |
| configMap.put(configName, config); |
| } |
| } |
| |
| return config; |
| } |
| |
| public void makeClosure() { |
| ConfigurationClosure c = getClosure(currentConfigName); |
| if (c != null) { |
| c.makeClosure(); |
| } |
| } |
| |
| } |