//------------------------------------------------------------------------------
// 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.properties;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
import org.eclipse.emf.edit.provider.ItemProviderAdapter;
import org.eclipse.epf.authoring.ui.AuthoringUIPlugin;
import org.eclipse.epf.authoring.ui.editors.ProcessEditor;
import org.eclipse.epf.common.serviceability.Logger;
import org.eclipse.epf.library.ILibraryManager;
import org.eclipse.epf.library.LibraryService;
import org.eclipse.epf.library.configuration.ProcessAuthoringConfigurator;
import org.eclipse.epf.library.edit.process.BreakdownElementWrapperItemProvider;
import org.eclipse.epf.library.edit.process.IBSItemProvider;
import org.eclipse.epf.library.edit.util.ProcessScopeUtil;
import org.eclipse.epf.library.edit.util.ProcessUtil;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.library.events.ILibraryChangeListener;
import org.eclipse.epf.library.util.LibraryUtil;
import org.eclipse.epf.uma.BreakdownElement;
import org.eclipse.epf.uma.Descriptor;
import org.eclipse.epf.uma.MethodConfiguration;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.RoleDescriptor;
import org.eclipse.epf.uma.util.Scope;
import org.eclipse.jface.util.Assert;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.views.properties.tabbed.AbstractPropertySection;
import org.eclipse.ui.views.properties.tabbed.ISection;
import org.eclipse.ui.views.properties.tabbed.TabContents;
import org.eclipse.ui.views.properties.tabbed.TabbedPropertySheetPage;
/**
* Base class for a section in a tab in the properties view.
*
* @author Shilpa Toraskar
* @since 1.0
*/
public class AbstractSection extends AbstractPropertySection implements
PropertyChangeListener {
protected BreakdownElement element;
protected boolean editable = false;
protected TabbedPropertySheetPage page;
protected ProcessAuthoringConfigurator configurator = new ProcessAuthoringConfigurator(
LibraryService.getInstance().getCurrentMethodConfiguration());
protected Logger logger;
/*
* Create an instance
*/
public AbstractSection() {
super();
// listen to change for current selection of MethodConfiguration
ILibraryManager manager = LibraryService.getInstance().getCurrentLibraryManager();
if (manager != null) {
manager.addListener(libraryListener);
}
// get logger
logger = AuthoringUIPlugin.getDefault().getLogger();
}
/**
* @see org.eclipse.ui.views.properties.tabbed.AbstractPropertySection#createControls(org.eclipse.swt.widgets.Composite, org.eclipse.ui.views.properties.tabbed.TabbedPropertySheetPage)
*/
public void createControls(Composite comp, TabbedPropertySheetPage page) {
super.createControls(comp, page);
this.page = page;
}
private ILibraryChangeListener libraryListener = new ILibraryChangeListener() {
public void libraryChanged(int option, Collection collection) {
switch (option) {
case ILibraryChangeListener.OPTION_CHANGED: {
sectionRefresh();
}
}
}
};
/**
* Refresh the current section
*
*/
private void sectionRefresh() {
if (page != null) {
TabContents tab = page.getCurrentTab();
if (tab != null) {
ISection section = tab.getSectionAtIndex(0);
if ((section != null)
&& (section instanceof BreakdownElementGeneralSection)) {
section.refresh();
}
}
}
}
/**
* @see org.eclipse.ui.views.properties.tabbed.AbstractPropertySection#dispose()
*/
public void dispose() {
super.dispose();
if (libraryListener != null) {
ILibraryManager manager = LibraryService.getInstance().getCurrentLibraryManager();
if (manager != null) {
manager.removeListener(libraryListener);
}
}
}
/**
* @see org.eclipse.ui.views.properties.tabbed.AbstractPropertySection#setInput(org.eclipse.ui.IWorkbenchPart, org.eclipse.jface.viewers.ISelection)
*/
public void setInput(IWorkbenchPart part, ISelection selection) {
super.setInput(part, selection);
// System.out.println("SetInput::selection - "+selection);
Assert.isTrue(selection instanceof IStructuredSelection);
Object input = ((IStructuredSelection) selection).getFirstElement();
initElementData(input);
}
private void initElementData(Object input) {
if (input instanceof BreakdownElement) {
this.element = (BreakdownElement) input;
if (TngUtil.isLocked(this.element))
this.editable = false;
else {
this.editable = true;
if (element instanceof RoleDescriptor) {
RoleDescriptor roleDesc = (RoleDescriptor) element;
if ((roleDesc.getSuperActivities() == null)
|| (roleDesc.getSuperActivities() == null))
this.editable = false;
else
this.editable = true;
}
}
} else if (input instanceof BreakdownElementWrapperItemProvider) {
this.element = (BreakdownElement) LibraryUtil.unwrap(input);
this.editable = false;
}
}
/**
* Return selection
*/
public ISelection getSelection() {
return EPFPropertySheetPage.getSelection();
}
/**
* Return first element from selection
*/
public Object getInput() {
ISelection selection = getSelection();
if (selection instanceof IStructuredSelection) {
Object input = ((IStructuredSelection) selection).getFirstElement();
return input;
}
return null;
}
/**
* Return process editor
*
* @return
* process editor
*/
public ProcessEditor getEditor() {
return EPFPropertySheetPage.getEditor();
}
/**
* Return ItemProvider
*
* @return
* adapter
*/
public ItemProviderAdapter getAdapter() {
try {
AdapterFactory factory = EPFPropertySheetPage.getAdapterFactory();
ItemProviderAdapter provider = (ItemProviderAdapter) factory.adapt(
element, ITreeItemContentProvider.class);
return provider;
} catch (Exception ex) {
return null;
}
}
/**
* Return Adapter factory
*
* @return
* adapter factory
*/
public AdapterFactory getAdapterFactory() {
AdapterFactory adapterFactory = EPFPropertySheetPage
.getAdapterFactory();
return adapterFactory;
}
/**
* Get the element.
*
* @return the element.
*/
public BreakdownElement getElement() {
ISelection selection = getSelection();
if (selection instanceof IStructuredSelection) {
Object input = ((IStructuredSelection) selection).getFirstElement();
// System.out.println("getElement::selection - "+selection);
try {
initElementData(input);
} catch (Exception e) {
logger
.logError(
"Error getting element from the selection " + element, e); //$NON-NLS-1$
return null;
}
return element;
}
return null;
}
/**
* Return property sheet page
* @return
* property sheet page
*/
public TabbedPropertySheetPage getPropertySheetPage() {
return this.page;
}
/**
* @see java.beans.PropertyChangeListener#propertyChange(java.beans.PropertyChangeEvent)
*/
public void propertyChange(PropertyChangeEvent evt) {
// System.out.println("ProeprtyChangeEvent" + evt);
refresh();
}
/**
* Return filter list of elements. Filter is based on current method configuration
* @param list
* Original list
* @return
* filtered list
*/
public List getFilteredList(List list) {
List newList = new ArrayList();
if (configurator != null) {
boolean toSetConfig = true;
if (getEditor() != null || getEditor().getSelectedProcess() != null) {
Scope scope = ProcessScopeUtil.getInstance().getScope(getEditor().getSelectedProcess());
if (scope != null) {
configurator.setMethodConfiguration(scope);
toSetConfig = false;
}
}
if (toSetConfig) {
configurator.setMethodConfiguration(LibraryService
.getInstance().getCurrentMethodConfiguration());
}
}
for (Iterator itor = list.iterator(); itor.hasNext();) {
if (configurator != null) {
Object obj = (Object) itor.next();
// configurator.setMethodConfiguration(LibraryService
// .getInstance().getCurrentMethodConfiguration());
if (configurator.accept(obj)) {
newList.add(obj);
}
}
}
return newList;
}
/**
* Get default method configuration
*
* @return
* default method configuration
*/
protected MethodConfiguration getDefaultConfiguration() {
ItemProviderAdapter adapter = (ItemProviderAdapter) getAdapter();
Object parent = null;
if (adapter instanceof IBSItemProvider) {
IBSItemProvider bsItemProvider = (IBSItemProvider) adapter;
parent = bsItemProvider.getTopItem();
MethodConfiguration config = ((org.eclipse.epf.uma.Process) parent)
.getDefaultContext();
return config;
} else {
logger
.logError("AbstractSection::getDefaultConfiguration - IBSItemProvider is null"); //$NON-NLS-1$
return null;
}
}
/**
* Return current method configuration
*
* @return
* current method configuration
*/
public MethodConfiguration getConfiguration() {
if (getEditor() != null) {
Scope scope = ProcessScopeUtil.getInstance().getScope(
getEditor().getSelectedProcess());
if (scope != null) {
int scopeType = ProcessScopeUtil.getInstance().getElemementSelectionScopeType();
if (scopeType == ProcessScopeUtil.ScopeType_Config) {
MethodConfiguration config = LibraryService.getInstance()
.getCurrentMethodConfiguration();
// if (config == null) {
// return scope;
// }
return config;
}
if (scopeType == ProcessScopeUtil.ScopeType_Process) {
return scope;
}
if (scopeType == ProcessScopeUtil.ScopeType_Library) {
return ProcessScopeUtil.getInstance().getLibraryScope();
}
if (scopeType == ProcessScopeUtil.ScopeType_Plugins) {
return ProcessScopeUtil.getInstance().getPluginScope();
}
}
}
MethodConfiguration config = LibraryService.getInstance()
.getCurrentMethodConfiguration();
if (config == null) {
// if configuration is not selected, use default configuration
return getDefaultConfiguration();
}
return config;
}
// public void updateTitle(Object obj)
// {
// String name = getNamePrefix() + ((BreakdownElement)obj).getName();
// TabbedPropertyComposite comp = (TabbedPropertyComposite)
// page.getControl();
// TabbedPropertyTitle title = comp.getTitle();
// if (titleImage == null)
// {
// titleImage = Display.getCurrent().getActiveShell().getImage();
// }
// title.setTitle(name, titleImage);
// }
/**
* Get name prefix for the element
*/
public String getNamePrefix() {
return "ProcessElement: "; //$NON-NLS-1$
}
protected AbstractSection getSection() {
return this;
}
protected boolean isSyncFree() {
return false;
}
protected void removeOutdatedReferences(MethodElement element, EReference eRef, Set validValueSet) {
if (! (element instanceof Descriptor) || ProcessUtil.getAssociatedElement((Descriptor) element) == null) {
return;
}
Object value = element.eGet(eRef);
if (! (value instanceof List)) {
return;
}
List list = (List) value;
if (list.isEmpty()) {
return;
}
Set toRemoveSet = new HashSet();
for (Object obj : list) {
if (! validValueSet.contains(obj)) {
toRemoveSet.add(obj);
}
}
if (toRemoveSet.isEmpty()) {
return;
}
list.removeAll(toRemoveSet);
}
}