/******************************************************************************* | |
* 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 2.0 | |
* which accompanies this distribution, and is available at | |
* https://www.eclipse.org/legal/epl-2.0/ | |
* | |
* SPDX-License-Identifier: EPL-2.0 | |
* | |
* 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 | |
} | |
} |