Fixed all line endings of the repository
[simantics/platform.git] / 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                                 selectionLayer.selectCell(c, item.rowIndex, false, true);
112                 }
113                 selection = new StructuredSelection(items);
114                 fireEvents();
115         }
116         
117         
118         private List<Point> selectedCells = new ArrayList<Point>();
119         
120         @Override
121         public void handleLayerEvent(ILayerEvent event) {
122                 if (event instanceof CellSelectionEvent) {
123                         evaluateSeletedCells();
124                 } 
125         }
126         
127         /**
128          * Processes current selection to data indices.
129          */
130         private void evaluateSeletedCells() {
131                 selectedCells.clear();
132                 for (PositionCoordinate pc : selectionLayer.getSelectedCellPositions()) {
133                         ILayerCell cell = pc.getLayer().getCellByPosition(pc.columnPosition, pc.rowPosition);
134                         selectedCells.add(new Point(cell.getColumnIndex(), cell.getRowIndex()));
135                 }
136                 MapList<Integer, Integer> rowMap = new MapList<>();
137                 for (Point p : selectedCells) {
138                         rowMap.add(p.y, p.x);
139                 }
140                 List<RowSelectionItem> selectionItems = new ArrayList<>(rowMap.getKeySize());
141                 for (Integer row : rowMap.getKeys()) {
142                         List<Integer> cols = rowMap.getValues(row);
143                         int col[] = new int[cols.size()];
144                         for (int i = 0; i < col.length; i++)
145                                 col[i] = cols.get(i);
146                         selectionItems.add(new RowSelectionItem(treeData.getDataAtIndex(row), row, col));
147                 }
148                 this.selection = new StructuredSelection(selectionItems);
149                 fireEvents();
150         }
151         
152         private void fireEvents() {
153                 for (ISelectionChangedListener l : selectionListeners) {
154                         l.selectionChanged(new SelectionChangedEvent(this, selection));
155                 }
156                 for (ISelectionChangedListener l : postSelectionListeners) {
157                         l.selectionChanged(new SelectionChangedEvent(this, selection));
158                 }
159                 Event evt = new Event();
160                 evt.widget = natTable;
161                 evt.display = natTable.getDisplay();
162                 evt.data = selection;
163                 for (SelectionListener l : selListeners) {
164                         SelectionEvent sel = new SelectionEvent(evt);
165                         l.widgetSelected(sel);
166                 }
167         }
168         
169         public List<Point> getSelectedCells() {
170                 return selectedCells;
171         }
172
173 }