-package org.simantics.browsing.ui.nattable;\r
-\r
-import java.util.ArrayList;\r
-import java.util.Collection;\r
-import java.util.List;\r
-\r
-import org.eclipse.jface.viewers.IPostSelectionProvider;\r
-import org.eclipse.jface.viewers.ISelection;\r
-import org.eclipse.jface.viewers.ISelectionChangedListener;\r
-import org.eclipse.jface.viewers.ISelectionProvider;\r
-import org.eclipse.jface.viewers.SelectionChangedEvent;\r
-import org.eclipse.jface.viewers.StructuredSelection;\r
-import org.eclipse.nebula.widgets.nattable.NatTable;\r
-import org.eclipse.nebula.widgets.nattable.coordinate.PositionCoordinate;\r
-import org.eclipse.nebula.widgets.nattable.layer.ILayerListener;\r
-import org.eclipse.nebula.widgets.nattable.layer.cell.ILayerCell;\r
-import org.eclipse.nebula.widgets.nattable.layer.event.ILayerEvent;\r
-import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer;\r
-import org.eclipse.nebula.widgets.nattable.selection.event.CellSelectionEvent;\r
-import org.eclipse.swt.events.SelectionEvent;\r
-import org.eclipse.swt.events.SelectionListener;\r
-import org.eclipse.swt.graphics.Point;\r
-import org.eclipse.swt.widgets.Event;\r
-import org.simantics.utils.datastructures.MapList;\r
-import org.simantics.utils.ui.AdaptionUtils;\r
-\r
-public class NatTableSelectionAdaptor implements ISelectionProvider, IPostSelectionProvider, ILayerListener {\r
- NatTable natTable;\r
- SelectionLayer selectionLayer;\r
- GETreeData treeData;\r
- StructuredSelection selection;\r
- \r
- private List<ISelectionChangedListener> selectionListeners = new ArrayList<>();\r
- private List<ISelectionChangedListener> postSelectionListeners = new ArrayList<>();\r
- private List<SelectionListener> selListeners = new ArrayList<>();\r
- \r
- public NatTableSelectionAdaptor(NatTable natTable, SelectionLayer selectionLayer, GETreeData treeData) {\r
- this.natTable = natTable;\r
- this.selectionLayer = selectionLayer;\r
- this.natTable.addLayerListener(this);\r
- this.treeData = treeData;\r
- }\r
- \r
- @Override\r
- public void addSelectionChangedListener(ISelectionChangedListener listener) {\r
- selectionListeners.add(listener);\r
- }\r
- \r
- @Override\r
- public void removeSelectionChangedListener(ISelectionChangedListener listener) {\r
- selectionListeners.remove(listener);\r
- }\r
- \r
- @Override\r
- public void addPostSelectionChangedListener(ISelectionChangedListener listener) {\r
- postSelectionListeners.add(listener);\r
- }\r
- \r
- @Override\r
- public void removePostSelectionChangedListener(ISelectionChangedListener listener) {\r
- postSelectionListeners.remove(listener);\r
- }\r
- \r
- public void addSelectionListener(SelectionListener listener) {\r
- selListeners.add(listener);\r
- }\r
- \r
- public void removeSelectionListener(SelectionListener listener) {\r
- selListeners.remove(listener);\r
- }\r
- \r
- @Override\r
- public ISelection getSelection() {\r
- return selection;\r
- }\r
- \r
- @Override\r
- public void setSelection(ISelection selection) {\r
- if (!(selection instanceof StructuredSelection))\r
- throw new IllegalArgumentException("Selection must be structured selection");\r
- if (selection.isEmpty()) {\r
- selectionLayer.clear(false);\r
- natTable.redraw();\r
- return;\r
- }\r
- List<RowSelectionItem> rowItems = new ArrayList<>(AdaptionUtils.adaptToCollection(selection, RowSelectionItem.class));\r
- if (rowItems.size() > 0) {\r
- \r
- setSelectionExternal(rowItems);\r
- return;\r
- }\r
- Collection<TreeNode> nodes = AdaptionUtils.adaptToCollection(selection, TreeNode.class);\r
- if (nodes.size() > 0) {\r
- List<RowSelectionItem> selected = new ArrayList<>();\r
- int allCols[] = new int[selectionLayer.getColumnCount()];\r
- for (int i = 0; i < allCols.length; i++)\r
- allCols[i] = i;\r
- for (TreeNode n : nodes) {\r
- selected.add(new RowSelectionItem(n, n.listIndex, allCols));\r
- }\r
- setSelectionExternal(selected);\r
- return;\r
- }\r
- \r
- }\r
- \r
- private void setSelectionExternal(List<RowSelectionItem> items) {\r
- selectionLayer.clear(true);\r
- for (RowSelectionItem item : items) {\r
- for (int c : item.columnIndex)\r
- selectionLayer.selectCell(c, item.rowIndex, false, true);\r
- }\r
- selection = new StructuredSelection(items);\r
- fireEvents();\r
- }\r
- \r
- \r
- private List<Point> selectedCells = new ArrayList<Point>();\r
- \r
- @Override\r
- public void handleLayerEvent(ILayerEvent event) {\r
- if (event instanceof CellSelectionEvent) {\r
- evaluateSeletedCells();\r
- } \r
- }\r
- \r
- /**\r
- * Processes current selection to data indices.\r
- */\r
- private void evaluateSeletedCells() {\r
- selectedCells.clear();\r
- for (PositionCoordinate pc : selectionLayer.getSelectedCellPositions()) {\r
- ILayerCell cell = pc.getLayer().getCellByPosition(pc.columnPosition, pc.rowPosition);\r
- selectedCells.add(new Point(cell.getColumnIndex(), cell.getRowIndex()));\r
- }\r
- MapList<Integer, Integer> rowMap = new MapList<>();\r
- for (Point p : selectedCells) {\r
- rowMap.add(p.y, p.x);\r
- }\r
- List<RowSelectionItem> selectionItems = new ArrayList<>(rowMap.getKeySize());\r
- for (Integer row : rowMap.getKeys()) {\r
- List<Integer> cols = rowMap.getValues(row);\r
- int col[] = new int[cols.size()];\r
- for (int i = 0; i < col.length; i++)\r
- col[i] = cols.get(i);\r
- selectionItems.add(new RowSelectionItem(treeData.getDataAtIndex(row), row, col));\r
- }\r
- this.selection = new StructuredSelection(selectionItems);\r
- fireEvents();\r
- }\r
- \r
- private void fireEvents() {\r
- for (ISelectionChangedListener l : selectionListeners) {\r
- l.selectionChanged(new SelectionChangedEvent(this, selection));\r
- }\r
- for (ISelectionChangedListener l : postSelectionListeners) {\r
- l.selectionChanged(new SelectionChangedEvent(this, selection));\r
- }\r
- Event evt = new Event();\r
- evt.widget = natTable;\r
- evt.display = natTable.getDisplay();\r
- evt.data = selection;\r
- for (SelectionListener l : selListeners) {\r
- SelectionEvent sel = new SelectionEvent(evt);\r
- l.widgetSelected(sel);\r
- }\r
- }\r
- \r
- public List<Point> getSelectedCells() {\r
- return selectedCells;\r
- }\r
-\r
-}\r
+package org.simantics.browsing.ui.nattable;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.jface.viewers.IPostSelectionProvider;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.ISelectionChangedListener;
+import org.eclipse.jface.viewers.ISelectionProvider;
+import org.eclipse.jface.viewers.SelectionChangedEvent;
+import org.eclipse.jface.viewers.StructuredSelection;
+import org.eclipse.nebula.widgets.nattable.NatTable;
+import org.eclipse.nebula.widgets.nattable.coordinate.PositionCoordinate;
+import org.eclipse.nebula.widgets.nattable.layer.ILayerListener;
+import org.eclipse.nebula.widgets.nattable.layer.cell.ILayerCell;
+import org.eclipse.nebula.widgets.nattable.layer.event.ILayerEvent;
+import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer;
+import org.eclipse.nebula.widgets.nattable.selection.event.CellSelectionEvent;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.events.SelectionListener;
+import org.eclipse.swt.graphics.Point;
+import org.eclipse.swt.widgets.Event;
+import org.simantics.utils.datastructures.MapList;
+import org.simantics.utils.ui.AdaptionUtils;
+
+public class NatTableSelectionAdaptor implements ISelectionProvider, IPostSelectionProvider, ILayerListener {
+ NatTable natTable;
+ SelectionLayer selectionLayer;
+ GETreeData treeData;
+ StructuredSelection selection;
+
+ private List<ISelectionChangedListener> selectionListeners = new ArrayList<>();
+ private List<ISelectionChangedListener> postSelectionListeners = new ArrayList<>();
+ private List<SelectionListener> selListeners = new ArrayList<>();
+
+ public NatTableSelectionAdaptor(NatTable natTable, SelectionLayer selectionLayer, GETreeData treeData) {
+ this.natTable = natTable;
+ this.selectionLayer = selectionLayer;
+ this.natTable.addLayerListener(this);
+ this.treeData = treeData;
+ }
+
+ @Override
+ public void addSelectionChangedListener(ISelectionChangedListener listener) {
+ selectionListeners.add(listener);
+ }
+
+ @Override
+ public void removeSelectionChangedListener(ISelectionChangedListener listener) {
+ selectionListeners.remove(listener);
+ }
+
+ @Override
+ public void addPostSelectionChangedListener(ISelectionChangedListener listener) {
+ postSelectionListeners.add(listener);
+ }
+
+ @Override
+ public void removePostSelectionChangedListener(ISelectionChangedListener listener) {
+ postSelectionListeners.remove(listener);
+ }
+
+ public void addSelectionListener(SelectionListener listener) {
+ selListeners.add(listener);
+ }
+
+ public void removeSelectionListener(SelectionListener listener) {
+ selListeners.remove(listener);
+ }
+
+ @Override
+ public ISelection getSelection() {
+ return selection;
+ }
+
+ @Override
+ public void setSelection(ISelection selection) {
+ if (!(selection instanceof StructuredSelection))
+ throw new IllegalArgumentException("Selection must be structured selection");
+ if (selection.isEmpty()) {
+ selectionLayer.clear(false);
+ natTable.redraw();
+ return;
+ }
+ List<RowSelectionItem> rowItems = new ArrayList<>(AdaptionUtils.adaptToCollection(selection, RowSelectionItem.class));
+ if (rowItems.size() > 0) {
+
+ setSelectionExternal(rowItems);
+ return;
+ }
+ Collection<TreeNode> nodes = AdaptionUtils.adaptToCollection(selection, TreeNode.class);
+ if (nodes.size() > 0) {
+ List<RowSelectionItem> selected = new ArrayList<>();
+ int allCols[] = new int[selectionLayer.getColumnCount()];
+ for (int i = 0; i < allCols.length; i++)
+ allCols[i] = i;
+ for (TreeNode n : nodes) {
+ selected.add(new RowSelectionItem(n, n.listIndex, allCols));
+ }
+ setSelectionExternal(selected);
+ return;
+ }
+
+ }
+
+ private void setSelectionExternal(List<RowSelectionItem> items) {
+ selectionLayer.clear(true);
+ for (RowSelectionItem item : items) {
+ for (int c : item.columnIndex)
+ selectionLayer.selectCell(c, item.rowIndex, false, true);
+ }
+ selection = new StructuredSelection(items);
+ fireEvents();
+ }
+
+
+ private List<Point> selectedCells = new ArrayList<Point>();
+
+ @Override
+ public void handleLayerEvent(ILayerEvent event) {
+ if (event instanceof CellSelectionEvent) {
+ evaluateSeletedCells();
+ }
+ }
+
+ /**
+ * Processes current selection to data indices.
+ */
+ private void evaluateSeletedCells() {
+ selectedCells.clear();
+ for (PositionCoordinate pc : selectionLayer.getSelectedCellPositions()) {
+ ILayerCell cell = pc.getLayer().getCellByPosition(pc.columnPosition, pc.rowPosition);
+ selectedCells.add(new Point(cell.getColumnIndex(), cell.getRowIndex()));
+ }
+ MapList<Integer, Integer> rowMap = new MapList<>();
+ for (Point p : selectedCells) {
+ rowMap.add(p.y, p.x);
+ }
+ List<RowSelectionItem> selectionItems = new ArrayList<>(rowMap.getKeySize());
+ for (Integer row : rowMap.getKeys()) {
+ List<Integer> cols = rowMap.getValues(row);
+ int col[] = new int[cols.size()];
+ for (int i = 0; i < col.length; i++)
+ col[i] = cols.get(i);
+ selectionItems.add(new RowSelectionItem(treeData.getDataAtIndex(row), row, col));
+ }
+ this.selection = new StructuredSelection(selectionItems);
+ fireEvents();
+ }
+
+ private void fireEvents() {
+ for (ISelectionChangedListener l : selectionListeners) {
+ l.selectionChanged(new SelectionChangedEvent(this, selection));
+ }
+ for (ISelectionChangedListener l : postSelectionListeners) {
+ l.selectionChanged(new SelectionChangedEvent(this, selection));
+ }
+ Event evt = new Event();
+ evt.widget = natTable;
+ evt.display = natTable.getDisplay();
+ evt.data = selection;
+ for (SelectionListener l : selListeners) {
+ SelectionEvent sel = new SelectionEvent(evt);
+ l.widgetSelected(sel);
+ }
+ }
+
+ public List<Point> getSelectedCells() {
+ return selectedCells;
+ }
+
+}
Code Review / simantics / platform.git / blobdiff