bundles/org.simantics.browsing.ui.nattable/src/org/simantics/browsing/ui/nattable/NatTableSelectionAdaptor.java

   1 package org.simantics.browsing.ui.nattable;
   2
   3 import java.util.ArrayList;
   4 import java.util.Collection;
   5 import java.util.List;
   6
   7 import org.eclipse.jface.viewers.IPostSelectionProvider;
   8 import org.eclipse.jface.viewers.ISelection;
   9 import org.eclipse.jface.viewers.ISelectionChangedListener;
  10 import org.eclipse.jface.viewers.ISelectionProvider;
  11 import org.eclipse.jface.viewers.SelectionChangedEvent;
  12 import org.eclipse.jface.viewers.StructuredSelection;
  13 import org.eclipse.nebula.widgets.nattable.NatTable;
  14 import org.eclipse.nebula.widgets.nattable.coordinate.PositionCoordinate;
  15 import org.eclipse.nebula.widgets.nattable.layer.ILayerListener;
  16 import org.eclipse.nebula.widgets.nattable.layer.cell.ILayerCell;
  17 import org.eclipse.nebula.widgets.nattable.layer.event.ILayerEvent;
  18 import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer;
  19 import org.eclipse.nebula.widgets.nattable.selection.event.CellSelectionEvent;
  20 import org.eclipse.swt.events.SelectionEvent;
  21 import org.eclipse.swt.events.SelectionListener;
  22 import org.eclipse.swt.graphics.Point;
  23 import org.eclipse.swt.widgets.Event;
  24 import org.simantics.utils.datastructures.MapList;
  25 import org.simantics.utils.ui.AdaptionUtils;
  26
  27 public class NatTableSelectionAdaptor implements ISelectionProvider, IPostSelectionProvider, ILayerListener {
  28         NatTable natTable;
  29         SelectionLayer selectionLayer;
  30         GETreeData treeData;
  31         StructuredSelection selection;
  32
  33         private List<ISelectionChangedListener> selectionListeners = new ArrayList<>();
  34         private List<ISelectionChangedListener> postSelectionListeners = new ArrayList<>();
  35         private List<SelectionListener> selListeners = new ArrayList<>();
  36
  37         public NatTableSelectionAdaptor(NatTable natTable, SelectionLayer selectionLayer, GETreeData treeData) {
  38                 this.natTable = natTable;
  39                 this.selectionLayer = selectionLayer;
  40                 this.natTable.addLayerListener(this);
  41                 this.treeData = treeData;
  42         }
  43
  44         @Override
  45         public void addSelectionChangedListener(ISelectionChangedListener listener) {
  46                 selectionListeners.add(listener);
  47         }
  48
  49         @Override
  50         public void removeSelectionChangedListener(ISelectionChangedListener listener) {
  51                 selectionListeners.remove(listener);
  52         }
  53
  54         @Override
  55         public void addPostSelectionChangedListener(ISelectionChangedListener listener) {
  56                 postSelectionListeners.add(listener);
  57         }
  58
  59         @Override
  60         public void removePostSelectionChangedListener(ISelectionChangedListener listener) {
  61                 postSelectionListeners.remove(listener);
  62         }
  63
  64         public void addSelectionListener(SelectionListener listener) {
  65                 selListeners.add(listener);
  66         }
  67
  68         public void removeSelectionListener(SelectionListener listener) {
  69                 selListeners.remove(listener);
  70         }
  71
  72         @Override
  73         public ISelection getSelection() {
  74                 return selection;
  75         }
  76
  77         @Override
  78         public void setSelection(ISelection selection) {
  79                 if (!(selection instanceof StructuredSelection))
  80                         throw new IllegalArgumentException("Selection must be structured selection");
  81                 if (selection.isEmpty()) {
  82                         selectionLayer.clear(false);
  83                         natTable.redraw();
  84                         return;
  85                 }
  86                 List<RowSelectionItem> rowItems = new ArrayList<>(AdaptionUtils.adaptToCollection(selection, RowSelectionItem.class));
  87                 if (rowItems.size() > 0) {
  88
  89                         setSelectionExternal(rowItems);
  90                         return;
  91                 }
  92                 Collection<TreeNode> nodes = AdaptionUtils.adaptToCollection(selection, TreeNode.class);
  93                 if (nodes.size() > 0) {
  94                         List<RowSelectionItem> selected = new ArrayList<>();
  95                         int allCols[] = new int[selectionLayer.getColumnCount()];
  96                         for (int i = 0; i < allCols.length; i++)
  97                                 allCols[i] = i;
  98                         for (TreeNode n : nodes) {
  99                                 selected.add(new RowSelectionItem(n, n.listIndex, allCols));
 100                         }
 101                         setSelectionExternal(selected);
 102                         return;
 103                 }
 104
 105         }
 106
 107         private void setSelectionExternal(List<RowSelectionItem> items) {
 108                 selectionLayer.clear(true);
 109                 for (RowSelectionItem item : items) {
 110                         for (int c : item.columnIndex) {
 111                                 int r = selectionLayer.getRowPositionByIndex(item.rowIndex);
 112                                 selectionLayer.selectCell(c, r, false, true);
 113                         }
 114                 }
 115                 selection = new StructuredSelection(items);
 116                 fireEvents();
 117         }
 118
 119
 120         private List<Point> selectedCells = new ArrayList<Point>();
 121
 122         @Override
 123         public void handleLayerEvent(ILayerEvent event) {
 124                 if (event instanceof CellSelectionEvent) {
 125                         evaluateSeletedCells();
 126                 }
 127         }
 128
 129         /**
 130          * Processes current selection to data indices.
 131          */
 132         private void evaluateSeletedCells() {
 133                 selectedCells.clear();
 134                 for (PositionCoordinate pc : selectionLayer.getSelectedCellPositions()) {
 135                         ILayerCell cell = pc.getLayer().getCellByPosition(pc.columnPosition, pc.rowPosition);
 136                         selectedCells.add(new Point(cell.getColumnIndex(), cell.getRowIndex()));
 137                 }
 138                 MapList<Integer, Integer> rowMap = new MapList<>();
 139                 for (Point p : selectedCells) {
 140                         rowMap.add(p.y, p.x);
 141                 }
 142                 List<RowSelectionItem> selectionItems = new ArrayList<>(rowMap.getKeySize());
 143                 for (Integer row : rowMap.getKeys()) {
 144                         List<Integer> cols = rowMap.getValues(row);
 145                         int col[] = new int[cols.size()];
 146                         for (int i = 0; i < col.length; i++)
 147                                 col[i] = cols.get(i);
 148                         selectionItems.add(new RowSelectionItem(treeData.getDataAtIndex(row), row, col));
 149                 }
 150                 this.selection = new StructuredSelection(selectionItems);
 151                 fireEvents();
 152         }
 153
 154         private void fireEvents() {
 155                 for (ISelectionChangedListener l : selectionListeners) {
 156                         l.selectionChanged(new SelectionChangedEvent(this, selection));
 157                 }
 158                 for (ISelectionChangedListener l : postSelectionListeners) {
 159                         l.selectionChanged(new SelectionChangedEvent(this, selection));
 160                 }
 161                 Event evt = new Event();
 162                 evt.widget = natTable;
 163                 evt.display = natTable.getDisplay();
 164                 evt.data = selection;
 165                 for (SelectionListener l : selListeners) {
 166                         SelectionEvent sel = new SelectionEvent(evt);
 167                         l.widgetSelected(sel);
 168                 }
 169         }
 170
 171         public List<Point> getSelectedCells() {
 172                 return selectedCells;
 173         }
 174
 175 }