/*******************************************************************************
* Copyright (c) 2005, 2012 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 API and implementation
*******************************************************************************/
package org.eclipse.bpel.ui.details.providers;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import org.eclipse.jface.viewers.IBaseLabelProvider;
import org.eclipse.jface.viewers.ICellModifier;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Item;
/**
* A TableProvider allows clients to register a label provider and an optional
* ICellModifier for each property they will display in the table. The TableProvider
* will delegate ITableLabelProvider and ICellModifier behaviour to the registered
* providers.
*
* Grouping related behaviours by column type (instead of grouping them by the
* behaviour type) will hopefully make maintenance of table code easier.
*
* IMPORTANT: The dispose() method of each registered label provider will be called
* when the TableProvider is disposed. If this is undesirable, clients can avoid it by
* unregistering the property before the TableProvider is disposed.
*/
public class TableProvider implements ITableLabelProvider, ICellModifier {
protected HashMap propertyToLabelProvider;
protected HashMap propertyToCellModifier;
protected ArrayList labelProviderListeners;
// NOTE: do not use columnProperties directly! Subclasses may change its
// semantics. Use getColumnProperty() or getColumnProperties().
protected String[] columnProperties;
public TableProvider() {
this.propertyToLabelProvider = new HashMap();
this.propertyToCellModifier = new HashMap();
labelProviderListeners = new ArrayList();
}
/**
* This method should be called with the properties being used for each column of
* the Table. If a TableViewer is used, these are the same values passed to the
* TableViewer's setColumnProperties() method. However, you must still call both
* methods because TableProvider doesn't know about the table viewer.
*
* TableProvider needs the columnProperties in order to delegate label provider
* behaviour to the correct registered label provider.
*/
public void setColumnProperties(String[] columnProperties) {
this.columnProperties = columnProperties;
}
/**
* Returns the columnProperties of this TableProvider.
*/
public String[] getColumnProperties() {
return columnProperties;
}
/**
* Returns a particular column's property. For some subclasses, this may be more
* efficient than using getColumnProperties().
*/
public String getColumnProperty(int index) {
return columnProperties[index];
}
/**
* Unregister the old label provider and cell modifier for the given property.
*
* @param property property to unregister.
*/
public void unregister(String property) {
IBaseLabelProvider oldLp = (IBaseLabelProvider)propertyToLabelProvider.remove(property);
propertyToCellModifier.remove(property);
if (oldLp != null) {
// remove all active listeners from the label provider.
for (Iterator it = labelProviderListeners.iterator(); it.hasNext(); ) {
oldLp.removeListener((ILabelProviderListener)it.next());
}
}
}
/**
* Unregister the old label provider and cell modifier for the given property.
*
* @param property property to register.
* @param lp label provider to use for the property. Must be an ILabelProvider or IBaseLabelProvider.
* @param cm ICellModifier to use for the property. May be null.
*/
public void register(String property, IBaseLabelProvider lp, ICellModifier cm) {
unregister(property);
// add all active listeners to the label provider.
for (Iterator it = labelProviderListeners.iterator(); it.hasNext(); ) {
lp.addListener((ILabelProviderListener)it.next());
}
propertyToLabelProvider.put(property, lp);
propertyToCellModifier.put(property, cm);
}
/* ITableLabelProvider */
public Image getColumnImage(Object element, int columnIndex) {
// delegate to the appropriate label provider.
Object lp = propertyToLabelProvider.get(columnProperties[columnIndex]);
if (lp instanceof ITableLabelProvider) {
return ((ITableLabelProvider)lp).getColumnImage(element, columnIndex);
}
if (lp instanceof ILabelProvider) {
return ((ILabelProvider)lp).getImage(element);
}
// no label provider found.
return null;
}
public String getColumnText(Object element, int columnIndex) {
// delegate to the appropriate label provider.
Object lp = propertyToLabelProvider.get(columnProperties[columnIndex]);
if (lp instanceof ITableLabelProvider) {
return ((ITableLabelProvider)lp).getColumnText(element, columnIndex);
}
if (lp instanceof ILabelProvider) {
return ((ILabelProvider)lp).getText(element);
}
// no label provider found.
return null;
}
/* IBaseLabelProvider */
public void addListener(ILabelProviderListener listener) {
labelProviderListeners.add(listener);
// add the listener to all label providers.
for (Iterator it = propertyToLabelProvider.values().iterator(); it.hasNext(); ) {
((IBaseLabelProvider)it.next()).addListener(listener);
}
}
public void removeListener(ILabelProviderListener listener) {
labelProviderListeners.add(listener);
// remove the listener from all label providers.
for (Iterator it = propertyToLabelProvider.values().iterator(); it.hasNext(); ) {
((IBaseLabelProvider)it.next()).removeListener(listener);
}
}
public void dispose() {
// dispose all registered label providers.
for (Iterator it = propertyToLabelProvider.values().iterator(); it.hasNext(); ) {
((IBaseLabelProvider)it.next()).dispose();
}
}
public boolean isLabelProperty(Object element, String property) {
// TODO: simplify this by just always returning true?
// return true if any registered label provider returns true.
for (Iterator it = propertyToLabelProvider.values().iterator(); it.hasNext(); ) {
if (((IBaseLabelProvider)it.next()).isLabelProperty(element, property)) return true;
}
return false;
}
/* ICellModifier */
public boolean canModify(Object element, String property) {
// delegate to the appropriate cell modifier.
ICellModifier cm = (ICellModifier)propertyToCellModifier.get(property);
if (cm != null) return cm.canModify(element, property);
// no cell modifier found.
return false;
}
public Object getValue(Object element, String property) {
// delegate to the appropriate cell modifier.
ICellModifier cm = (ICellModifier)propertyToCellModifier.get(property);
if (cm != null) return cm.getValue(element, property);
// no cell modifier found.
return null;
}
public void modify(Object element, String property, Object value) {
if (element instanceof Item) element = ((Item)element).getData();
// delegate to the appropriate cell modifier.
ICellModifier cm = (ICellModifier)propertyToCellModifier.get(property);
if (cm != null) { cm.modify(element, property, value); return; }
// no cell modifier found.
// do nothing
}
}