| // RelativeValueViewExample.java |
| package org.eclipse.stem.sample.adaption; |
| |
| /******************************************************************************* |
| * Copyright (c) 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 API and implementation |
| *******************************************************************************/ |
| |
| import java.text.NumberFormat; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.emf.edit.provider.ItemPropertyDescriptor; |
| import org.eclipse.jface.viewers.ILabelProvider; |
| import org.eclipse.jface.viewers.ILabelProviderListener; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.ITableColorProvider; |
| import org.eclipse.jface.viewers.ITableLabelProvider; |
| import org.eclipse.jface.viewers.ITreeContentProvider; |
| import org.eclipse.jface.viewers.TreeViewer; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.jface.viewers.ViewerSorter; |
| import org.eclipse.stem.core.graph.Graph; |
| import org.eclipse.stem.core.graph.NodeLabel; |
| import org.eclipse.stem.core.model.Decorator; |
| import org.eclipse.stem.definitions.adapters.relativevalue.RelativeValueProvider; |
| import org.eclipse.stem.definitions.adapters.relativevalue.RelativeValueProviderAdapterFactory; |
| import org.eclipse.stem.jobs.simulation.ISimulation; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.graphics.Color; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Tree; |
| import org.eclipse.swt.widgets.TreeColumn; |
| import org.eclipse.ui.ISelectionListener; |
| import org.eclipse.ui.ISelectionService; |
| import org.eclipse.ui.IWorkbenchPart; |
| import org.eclipse.ui.part.ViewPart; |
| |
| /** |
| * This class is an example of how to run GUI code in Eclipse and monitor the |
| * "selected" simulation, and how to extract the canonical graph from the |
| * selected simulation and then extract data from it. In particular, this |
| * example view illustrates how to explore the canonical graph and discover |
| * property values of graph components that can be represented as a value |
| * between 0.0 and 1.0 (inclusive) relative to other peer property values. For |
| * instance, in the case of a disease model, the disease model label values |
| * contain population numbers for population members in different disease states |
| * (e.g., "susceptible", "exposed", "infectious", "recovered"). The number of |
| * members in each state can be represented relative to the total population |
| * figure (i.e., as a percentage of the sum of all the states). The relative |
| * values can be interpreted by a generic graphical interface to display |
| * different colors or intensities to represent the property value. |
| * <p> |
| * The discovery of properties and their conversion to relative values is |
| * facilitated by an interface called {@link RelativeValueProvider}. Instances |
| * of classes that implement this interface can provide a list of properties for |
| * which relative values can be generated, and, given one of those properties, |
| * can generate its relative value. The properties contain details such as the |
| * name of the property and a text description, among other things. These values |
| * could be presented to a user of a graphical interface in a menu to select the |
| * (relative) property values to display. The trick, and the point of this |
| * example, is obtaining {@link RelativeValueProvider}'s for components of the |
| * graph. |
| * <p> |
| * Instances of {@link RelativeValueProvider} are created by an adapter factory |
| * called {@link RelativeValueProviderAdapterFactory}. This adapter factory can |
| * be given any component in a graph and, if possible, create a |
| * {@link RelativeValueProvider} for it. If it can't, it simply returns |
| * <code>null</code> as the result of the attempt. The factory can be |
| * generically extended to encompass new graph components. This allows clients |
| * of the factory to obtain adapters for future enhancements with no change to |
| * the interface. An example of this is the |
| * {@link org.eclipse.stem.diseasemodels.standard.provider.StandardRelativeValueProviderAdapterFactory} |
| * which provides relative values for properties of the "standard" STEM disease |
| * model components, in particular, for the disease model label values (e.g., |
| * {@link org.eclipse.stem.diseasemodels.standard.SILabelValue}, |
| * {@link org.eclipse.stem.diseasemodels.standard.SIRLabelValue}, and |
| * {@link org.eclipse.stem.diseasemodels.standard.SEIRLabelValue}). |
| * <p> |
| * This example illustrates how to track which simulation is selected and then |
| * how to extract the simulation's underlying |
| * {@link org.eclipse.stem.core.scenario.Scenario} and then from that obtain |
| * the <em>canonical graph</em>. The canonical graph is the actual graph used |
| * to represent the simulation state information. The simulation proceeds by |
| * updating the values of labels on edges and nodes in the graph. The example |
| * shows how to obtain the decorators (e.g., disease models such as |
| * {@link org.eclipse.stem.diseasemodels.standard.DeterministicSEIRDiseaseModel}) |
| * that update the state of the graph and then from those discover properties |
| * that can have relative values. The example then shows how to use the adapter |
| * factory to create {@link RelativeValueProvider}'s. |
| * <p> |
| * To see the example in action, you need to: |
| * <ol> |
| * <li> Run STEM</li> |
| * <li> Open the "Relative Value View Example" view. |
| * "Window->Show View->Other->STEM->Relative Value View Example"</li> |
| * <li> Open the "Active Simulations" view. |
| * "Window->Show View->Active Simulations"</li>. |
| * |
| * <li> Go to the "Scenarios" view. It shows the STEM Scenarios that are plugged |
| * into STEM. </li> |
| * <li> Expand "Test->Disease Models->Standard" and you'll see disease |
| * modeling scenarios that are plugged into STEM. </li> |
| * <li> Double-click on a scenario in the list (e.g., "SEIR 1 x 1") it will |
| * begin simulation and an entry will appear in the "Active Simulations" view. |
| * </li> |
| * <li> Single click on the entry in the Active Simulations view. This will |
| * select that simulation and the relative values for that scenario will appear |
| * in the Relative Value View Example view.</li> |
| * </ol> |
| * If you double-click on another plugged-in Scenario so that two entries are |
| * displayed in the Active Simulations view and if you select both, you'll see |
| * data from both simulations. |
| * |
| */ |
| public class RelativeValueViewExample extends ViewPart { |
| |
| /** |
| * The identifier of the Relative Value View Example View. Nobody uses this |
| * right now, but it would be useful if we wanted to programatically add |
| * this view to a perspective. |
| */ |
| public static final String ID_VIEW_EXAMPLE1_VIEW = "org.eclipse.stem.sample.adapter.relativevalueviewexample"; |
| |
| private static final int NUMBER_OF_FRACTIONAL_DIGITS = 2; |
| |
| TreeViewer treeViewer = null; |
| |
| private static NumberFormat formatter = null; |
| |
| /** |
| * @return a number formatter |
| */ |
| protected static NumberFormat getFormatter() { |
| // Is there already a formatter? |
| if (formatter == null) { |
| // No |
| formatter = NumberFormat.getNumberInstance(); |
| formatter.setMaximumFractionDigits(NUMBER_OF_FRACTIONAL_DIGITS); |
| formatter.setMinimumFractionDigits(NUMBER_OF_FRACTIONAL_DIGITS); |
| } |
| return formatter; |
| } // getFormatter |
| |
| /** |
| * This method is called when the view is created and it has the |
| * responsibility for doing all of the initialization. It creates the |
| * TreeViewer and instances of the ContentProvider and LabelProvider for the |
| * viewer. It also gets a reference to the selection service and registers |
| * the content provider so it will be notified when something is selected. |
| * |
| * @see org.eclipse.ui.part.WorkbenchPart#createPartControl(org.eclipse.swt.widgets.Composite) |
| */ |
| @Override |
| public void createPartControl(Composite parent) { |
| // Create the TreeViewer |
| treeViewer = new TreeViewer(parent, SWT.FULL_SELECTION | SWT.H_SCROLL |
| | SWT.V_SCROLL); |
| |
| final Tree tree = treeViewer.getTree(); |
| tree.setLinesVisible(true); |
| tree.setHeaderVisible(true); |
| |
| final TreeColumn simulationColumn = new TreeColumn(tree, SWT.NONE); |
| simulationColumn.setText("Simulation"); |
| simulationColumn.setResizable(true); |
| simulationColumn.setWidth(200); |
| simulationColumn.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(@SuppressWarnings("unused") |
| SelectionEvent e) { |
| ((RelativeValueViewSorter) treeViewer.getSorter()).doSort(0); |
| treeViewer.refresh(true); |
| } |
| }); |
| |
| final TreeColumn decoratorColumn = new TreeColumn(tree, SWT.NONE); |
| decoratorColumn.setText("Decorator"); |
| decoratorColumn.setResizable(true); |
| decoratorColumn.setWidth(200); |
| decoratorColumn.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(@SuppressWarnings("unused") |
| SelectionEvent e) { |
| ((RelativeValueViewSorter) treeViewer.getSorter()).doSort(1); |
| treeViewer.refresh(true); |
| } |
| }); |
| |
| final TreeColumn nodeColumn = new TreeColumn(tree, SWT.NONE); |
| nodeColumn.setText("Node"); |
| nodeColumn.setResizable(true); |
| nodeColumn.setWidth(100); |
| nodeColumn.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(@SuppressWarnings("unused") |
| SelectionEvent e) { |
| ((RelativeValueViewSorter) treeViewer.getSorter()).doSort(2); |
| treeViewer.refresh(true); |
| } |
| }); |
| |
| final TreeColumn currentValueColumn = new TreeColumn(tree, SWT.NONE); |
| currentValueColumn.setText("Current Values"); |
| currentValueColumn.setResizable(true); |
| currentValueColumn.setWidth(100); |
| currentValueColumn.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(@SuppressWarnings("unused") |
| SelectionEvent e) { |
| ((RelativeValueViewSorter) treeViewer.getSorter()).doSort(3); |
| treeViewer.refresh(true); |
| } |
| }); |
| |
| final TreeColumn relativeValueColumn = new TreeColumn(tree, SWT.NONE); |
| relativeValueColumn.setText("Relative Values"); |
| relativeValueColumn.setResizable(true); |
| relativeValueColumn.setWidth(100); |
| currentValueColumn.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(@SuppressWarnings("unused") |
| SelectionEvent e) { |
| ((RelativeValueViewSorter) treeViewer.getSorter()).doSort(4); |
| treeViewer.refresh(true); |
| } |
| }); |
| |
| // Let the ListViewer know who its content and label providers are |
| treeViewer.setContentProvider(new RelativeValueViewContentProvider()); |
| treeViewer.setLabelProvider(new RelativeValueViewLabelProvider()); |
| treeViewer.setSorter(new RelativeValueViewSorter()); |
| |
| // This call tells the viewer's content provider where it should get the |
| // source of its content. In this case it is the selection service. |
| treeViewer.setInput(getSite().getWorkbenchWindow() |
| .getSelectionService()); |
| |
| // We also want to be able to have a user select a simluation from our |
| // view and have that be seen by others. So we register the TreeViewer |
| // instance as the view's selection provider. When you click on the view |
| // in the interface it finds the underlying Object (i.e., ISimulation) |
| // you selected and passes it to the selection service. |
| // getSite().setSelectionProvider(treeViewer); |
| |
| } // createPartControl |
| |
| /** |
| * This is required by the interface, but we're not using it. |
| * |
| * @see org.eclipse.ui.part.WorkbenchPart#setFocus() |
| */ |
| @Override |
| public void setFocus() { |
| // nothing |
| } // setFocus |
| |
| /** |
| * This class is the content provider. |
| */ |
| public class RelativeValueViewContentProvider implements |
| ITreeContentProvider, ISelectionListener { |
| |
| ISelectionService ss = null; |
| |
| private TreeViewer viewer = null; |
| |
| private List<ISimulation> selectedSimulations; |
| |
| /** |
| * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object) |
| */ |
| public Object[] getElements(Object inputElement) { |
| return new Object[] { inputElement }; |
| } // getElements |
| |
| /** |
| * @see org.eclipse.jface.viewers.IContentProvider#dispose() |
| */ |
| public void dispose() { |
| // TODO Auto-generated method stub |
| } |
| |
| /** |
| * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer, |
| * java.lang.Object, java.lang.Object) |
| */ |
| public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { |
| // We remember the TreeViewer we're providing content for because |
| // we'll have to change the list of things it contains in the |
| // selectionChanged method. |
| this.viewer = (TreeViewer) viewer; |
| |
| // Were we previously getting input from a different service? |
| if (oldInput != null) { |
| // Yes |
| // Not any more. |
| final ISelectionService oldSS = (ISelectionService) oldInput; |
| oldSS.removePostSelectionListener(this); |
| } |
| |
| // Is there some new input we should register with? |
| if (newInput != null) { |
| // Yes |
| // Register us with the new service. Since there should only |
| // really be one selection service in Eclipse, this would only |
| // happen once, however, the code can handle a change if needed. |
| ss = (ISelectionService) newInput; |
| ss.addPostSelectionListener(this); |
| } |
| |
| } // inputChanged |
| |
| /** |
| * @see org.eclipse.jface.viewers.ITreeContentProvider#getChildren(java.lang.Object) |
| */ |
| public Object[] getChildren(Object parentElement) { |
| Object[] retValue = null; |
| if (parentElement instanceof ISelectionService) { |
| retValue = selectedSimulations == null ? null |
| : selectedSimulations.toArray(); |
| } else if (parentElement instanceof ISimulation) { |
| ISimulation simulation = (ISimulation) parentElement; |
| retValue = simulation.getScenario().getCanonicalGraph() |
| .getDecorators().toArray(); |
| } else if (parentElement instanceof Decorator) { |
| Decorator decorator = (Decorator) parentElement; |
| retValue = decorator.getLabelsToUpdate().toArray(); |
| } |
| |
| // else if (parentElement instanceof Label) { |
| // Label label = (Label) parentElement; |
| // RelativeValueProvider rvp = (RelativeValueProvider) |
| // RelativeValueProviderAdapterFactory.INSTANCE |
| // .adapt(label, RelativeValueProvider.class); |
| // retValue = rvp.getProperties().toArray(); |
| // } |
| return retValue; |
| } // getChildren |
| |
| /** |
| * @see org.eclipse.jface.viewers.ITreeContentProvider#getParent(java.lang.Object) |
| */ |
| @SuppressWarnings("null") |
| public Object getParent(Object element) { |
| Object retValue = null; |
| if (element instanceof ISelectionService) { |
| retValue = null; |
| } else if (element instanceof ISimulation) { |
| retValue = ss; |
| } else if (element instanceof Decorator) { |
| Decorator decorator = (Decorator) element; |
| retValue = decorator.eContainer().eContainer(); |
| } |
| // if (element instanceof Label) { |
| // Label label = (Label) element; |
| // label.g |
| // } |
| return retValue; |
| } // getParent |
| |
| /** |
| * @see org.eclipse.jface.viewers.ITreeContentProvider#hasChildren(java.lang.Object) |
| */ |
| public boolean hasChildren(Object element) { |
| boolean retValue = false; |
| if (element instanceof ISelectionService) { |
| retValue = selectedSimulations != null |
| && selectedSimulations.size() > 0; |
| } else if (element instanceof ISimulation) { |
| final ISimulation simulation = (ISimulation) element; |
| final Graph canonicalGraph = simulation.getScenario() |
| .getCanonicalGraph(); |
| // Do we have a canonical Graph yet? |
| if (canonicalGraph != null) { |
| // Yes |
| retValue = canonicalGraph.getDecorators().size() > 0; |
| } // if |
| } else if (element instanceof Decorator) { |
| Decorator decorator = (Decorator) element; |
| retValue = decorator.getLabelsToUpdate().size() > 0; |
| } |
| |
| // else if (element instanceof Label) { |
| // Label label = (Label) element; |
| // RelativeValueProvider rvp = (RelativeValueProvider) |
| // RelativeValueProviderAdapterFactory.INSTANCE |
| // .adapt(label, RelativeValueProvider.class); |
| // retValue = rvp != null && rvp.getProperties().size() > 0; |
| // } |
| return retValue; |
| } // hasChildren |
| |
| /** |
| * @see org.eclipse.ui.ISelectionListener#selectionChanged(org.eclipse.ui.IWorkbenchPart, |
| * org.eclipse.jface.viewers.ISelection) |
| */ |
| public void selectionChanged(IWorkbenchPart part, ISelection selection) { |
| |
| // Is this selection changed event coming from our view? |
| if (part != RelativeValueViewExample.this) { |
| // No |
| // This will hold the new simulations that have been selected |
| final List<ISimulation> temp = new ArrayList<ISimulation>(); |
| |
| // Is it a structured selection? |
| if (selection instanceof IStructuredSelection) { |
| // Yes |
| final List list = ((IStructuredSelection) selection) |
| .toList(); |
| |
| // Go through everything in the list of things that were |
| // selected and pick out the ones that are ISimulations. |
| for (final Iterator selectionIter = list.iterator(); selectionIter |
| .hasNext();) { |
| final Object obj = selectionIter.next(); |
| if (obj instanceof ISimulation) { |
| temp.add((ISimulation) obj); |
| } |
| } // for each selected item |
| } // if structured selection |
| |
| // Did we find any new simulations that were selected? |
| if (temp.size() > 0) { |
| // Yes |
| // Tell the ListViewer not to redraw while we're changing |
| // its list. |
| viewer.getTree().setRedraw(false); |
| try { |
| // Do we have any old selections we should remove? |
| if (selectedSimulations != null) { |
| // Yes |
| viewer.remove(selectedSimulations.toArray()); |
| } |
| // Add the new selections to the ListViewer's list. It |
| // will use the label provider to get a text string for |
| // each one. |
| viewer.add(ss, temp.toArray()); |
| |
| // Remember what we added this time so we can remove it |
| // next selection. |
| selectedSimulations = temp; |
| } // try |
| finally { |
| // The ListViewer should update itself now. |
| viewer.getTree().setRedraw(true); |
| } |
| } // if any new simulations selected |
| } // if selection changed event coming from our view? |
| |
| } // selectionChanged |
| |
| } // RelativeValueViewContentProvider |
| |
| /** |
| * This class is a Label provider |
| */ |
| public static class RelativeValueViewLabelProvider implements ILabelProvider, |
| ITableLabelProvider, ITableColorProvider { |
| |
| private final List<ILabelProviderListener> listeners = new ArrayList<ILabelProviderListener>(); |
| |
| /** |
| * @see org.eclipse.jface.viewers.ILabelProvider#getImage(java.lang.Object) |
| */ |
| public Image getImage(@SuppressWarnings("unused") |
| Object element) { |
| return null; |
| } // getImage |
| |
| /** |
| * @see org.eclipse.jface.viewers.ILabelProvider#getText(java.lang.Object) |
| */ |
| public String getText(Object element) { |
| String retValue = ""; |
| if (element instanceof ISelectionService) { |
| retValue = "Active Simulations"; |
| } else if (element instanceof ISimulation) { |
| ISimulation simulation = (ISimulation) element; |
| retValue = simulation.getName() + " (" |
| + simulation.getSequenceNumber() + ")"; |
| } else if (element instanceof Decorator) { |
| Decorator decorator = (Decorator) element; |
| // final String title = decorator.getDublinCore().getTitle(); |
| // final StringBuilder sb = new StringBuilder(); |
| retValue = decorator.toString(); |
| } else if (element instanceof NodeLabel) { |
| NodeLabel nodeLabel = (NodeLabel) element; |
| retValue = nodeLabel.getNode().getDublinCore().getTitle(); |
| retValue = retValue == null ? "Label" : retValue; |
| } else if (element instanceof ItemPropertyDescriptor) { |
| ItemPropertyDescriptor property = (ItemPropertyDescriptor) element; |
| retValue = property.getDisplayName(null); |
| } |
| return retValue; |
| } // getText |
| |
| /** |
| * @see org.eclipse.jface.viewers.ITableLabelProvider#getColumnImage(java.lang.Object, |
| * int) |
| */ |
| public Image getColumnImage(@SuppressWarnings("unused") |
| Object element, @SuppressWarnings("unused") |
| int columnIndex) { |
| return null; |
| } // getColumnImage |
| |
| /** |
| * @see org.eclipse.jface.viewers.ITableLabelProvider#getColumnText(java.lang.Object, |
| * int) |
| */ |
| public String getColumnText(Object element, int columnIndex) { |
| String retValue = ""; |
| if (columnIndex == 0 && element instanceof ISelectionService) { |
| retValue = "Active Simulations"; |
| } else if (columnIndex == 0 && element instanceof ISimulation) { |
| ISimulation simulation = (ISimulation) element; |
| retValue = simulation.getName() + " (" |
| + simulation.getSequenceNumber() + ")"; |
| } else if (columnIndex == 1 && element instanceof Decorator) { |
| Decorator decorator = (Decorator) element; |
| // final String title = decorator.getDublinCore().getTitle(); |
| // final StringBuilder sb = new StringBuilder(); |
| retValue = decorator.toString(); |
| } else if (columnIndex == 2 && element instanceof NodeLabel) { |
| NodeLabel nodeLabel = (NodeLabel) element; |
| retValue = nodeLabel.getNode().getDublinCore().getTitle(); |
| retValue = retValue == null ? "Node" : retValue; |
| } |
| |
| else if (columnIndex == 3 && element instanceof NodeLabel) { |
| NodeLabel nodeLabel = (NodeLabel) element; |
| retValue = nodeLabel.getCurrentValue().toString(); |
| } // else index = 3 && NodeLabel |
| |
| else if (columnIndex == 4 && element instanceof NodeLabel) { |
| |
| RelativeValueProvider rvp = (RelativeValueProvider) RelativeValueProviderAdapterFactory.INSTANCE |
| .adapt(element, RelativeValueProvider.class); |
| // Does the label have relative values? |
| if (rvp != null) { |
| // Yes |
| |
| final StringBuilder sb = new StringBuilder(); |
| for (Iterator propertyIter = rvp.getProperties().iterator(); propertyIter |
| .hasNext();) { |
| ItemPropertyDescriptor property = (ItemPropertyDescriptor) propertyIter |
| .next(); |
| sb.append(property.getDisplayName(property)); |
| sb.append(": "); |
| |
| sb.append(getFormatter().format( |
| rvp.getRelativeValue(property))); |
| |
| if (propertyIter.hasNext()) { |
| sb.append(", "); |
| } |
| } // for each property |
| retValue = sb.toString(); |
| } // if |
| else { |
| retValue = ""; |
| } |
| } // else index = 4 && NodeLabel |
| |
| return retValue; |
| } // getColumnText |
| |
| /** |
| * @see org.eclipse.jface.viewers.ITableColorProvider#getBackground(java.lang.Object, |
| * int) |
| */ |
| public Color getBackground(@SuppressWarnings("unused") |
| Object element, @SuppressWarnings("unused") |
| int columnIndex) { |
| return null; |
| } |
| |
| /** |
| * @see org.eclipse.jface.viewers.ITableColorProvider#getForeground(java.lang.Object, |
| * int) |
| */ |
| public Color getForeground(@SuppressWarnings("unused") |
| Object element, @SuppressWarnings("unused") |
| int columnIndex) { |
| return null; |
| } |
| |
| /** |
| * @see org.eclipse.jface.viewers.IBaseLabelProvider#dispose() |
| */ |
| public void dispose() { |
| // TODO Auto-generated method stub |
| } |
| |
| /** |
| * @see org.eclipse.jface.viewers.IBaseLabelProvider#isLabelProperty(java.lang.Object, |
| * java.lang.String) |
| */ |
| public boolean isLabelProperty(@SuppressWarnings("unused") |
| Object element, @SuppressWarnings("unused") |
| String property) { |
| return false; |
| } |
| |
| /** |
| * @see org.eclipse.jface.viewers.IBaseLabelProvider#addListener(org.eclipse.jface.viewers.ILabelProviderListener) |
| */ |
| public void addListener(ILabelProviderListener listener) { |
| listeners.add(listener); |
| } // addListener |
| |
| /** |
| * @see org.eclipse.jface.viewers.IBaseLabelProvider#removeListener(org.eclipse.jface.viewers.ILabelProviderListener) |
| */ |
| public void removeListener(ILabelProviderListener listener) { |
| listeners.remove(listener); |
| } // removeListener |
| |
| } // RelativeValueViewLabelProvider |
| |
| /** |
| * This class implements the sorting of the RelativeValue View viewer |
| */ |
| public static class RelativeValueViewSorter extends ViewerSorter { |
| private static final int ASCENDING = 0; |
| |
| private static final int DESCENDING = 1; |
| |
| private int column = -1; |
| |
| private int direction = ASCENDING; |
| |
| /** |
| * @param column |
| * the column to sort |
| */ |
| public void doSort(int column) { |
| direction = this.column == column ? 1 - direction : ASCENDING; |
| this.column = column; |
| } |
| |
| /** |
| * @see org.eclipse.jface.viewers.ViewerComparator#compare(org.eclipse.jface.viewers.Viewer, |
| * java.lang.Object, java.lang.Object) |
| */ |
| @Override |
| public int compare(Viewer viewer, Object e1, Object e2) { |
| int rc = super.compare(viewer, e1, e2); |
| if (direction == DESCENDING) { |
| rc = -rc; |
| } |
| return rc; |
| } // compare |
| |
| } // RelativeValueViewSorter |
| } // RelativeValueViewExample |