-package org.simantics.browsing.ui.nattable;\r
-\r
-import java.util.ArrayList;\r
-import java.util.Collection;\r
-import java.util.Collections;\r
-import java.util.HashSet;\r
-import java.util.List;\r
-\r
-import org.eclipse.nebula.widgets.nattable.tree.ITreeData;\r
-import org.eclipse.nebula.widgets.nattable.tree.ITreeRowModel;\r
-import org.eclipse.nebula.widgets.nattable.tree.ITreeRowModelListener;\r
-\r
-import it.unimi.dsi.fastutil.ints.IntOpenHashSet;\r
-\r
-/**\r
- * ITreeRowModel that does not automatically expand all child nodes (as TreeRowModel does). \r
- * \r
- * @author Marko Luukkainen <marko.luukkainen@vtt.fi>\r
- *\r
- * @param <T>\r
- */\r
-public class GETreeRowModel<T> implements ITreeRowModel<T>{\r
- //private final HashSet<Integer> parentIndexes = new HashSet<Integer>();\r
- //private final TIntHashSet parentIndexes = new TIntHashSet(1000, 0.8f);\r
- private final IntOpenHashSet expandedIndexes = new IntOpenHashSet();\r
-\r
- private final Collection<ITreeRowModelListener> listeners = new HashSet<ITreeRowModelListener>();\r
-\r
- private final ITreeData<T> treeData;\r
-\r
- public GETreeRowModel(ITreeData<T> treeData) {\r
- this.treeData = treeData;\r
- }\r
-\r
- public void registerRowGroupModelListener(ITreeRowModelListener listener) {\r
- this.listeners.add(listener);\r
- }\r
-\r
- public void notifyListeners() {\r
- for (ITreeRowModelListener listener : this.listeners) {\r
- listener.treeRowModelChanged();\r
- }\r
- }\r
-\r
- public int depth(int index) {\r
- return this.treeData.getDepthOfData(this.treeData.getDataAtIndex(index));\r
- }\r
-\r
- public boolean isLeaf(int index) {\r
- return !hasChildren(index);\r
- }\r
-\r
- public String getObjectAtIndexAndDepth(int index, int depth) {\r
- return this.treeData.formatDataForDepth(depth,this.treeData.getDataAtIndex(index));\r
- }\r
-\r
- public boolean hasChildren(int index) {\r
- return this.treeData.hasChildren(this.treeData.getDataAtIndex(index));\r
- }\r
- \r
- public boolean isCollapsed(int index) {\r
- return !this.expandedIndexes.contains(index);\r
- }\r
-\r
- public void clear() {\r
- this.expandedIndexes.clear();\r
- }\r
- \r
- @Override\r
- public boolean isCollapsible(int index) {\r
- return hasChildren(index);\r
- }\r
-\r
- @Override\r
- public List<Integer> collapse(int index) {\r
- this.expandedIndexes.remove(index);\r
- notifyListeners();\r
- List<Integer> list = getChildIndexes(index);\r
- //this.parentIndexes.addAll(list);\r
- return list;\r
- }\r
- \r
- \r
-\r
- @Override\r
- public List<Integer> expand(int index) {\r
- this.expandedIndexes.add(index);\r
- notifyListeners();\r
- List<Integer> children = getExpandedChildIndexes(index);\r
- return children;\r
- }\r
- \r
- @Override\r
- public List<Integer> collapseAll() {\r
- return null;\r
- }\r
- \r
- \r
- @Override\r
- public List<Integer> expandToLevel(int level) {\r
- // TODO Auto-generated method stub\r
- return null;\r
- }\r
- \r
- @Override\r
- public List<Integer> expandToLevel(T object, int level) {\r
- // TODO Auto-generated method stub\r
- return null;\r
- }\r
- \r
- @Override\r
- public List<Integer> expandAll() {\r
- // TODO Auto-generated method stub\r
- return null;\r
- }\r
- \r
- @Override\r
- public List<Integer> expandToLevel(int parentIndex, int level) {\r
- // TODO Auto-generated method stub\r
- return null;\r
- }\r
- \r
- @Override\r
- public List<T> getChildren(int parentIndex) {\r
- T t = treeData.getDataAtIndex(parentIndex);\r
- return treeData.getChildren(t,true);\r
- }\r
- \r
- @Override\r
- public List<T> getDirectChildren(int parentIndex) {\r
- return treeData.getChildren(parentIndex);\r
- }\r
- \r
- \r
- @Override\r
- public List<Integer> collapse(T object) {\r
- int index = treeData.indexOf(object);\r
- return collapse(index);\r
- }\r
- \r
- @Override\r
- public List<Integer> expand(T object) {\r
- int index = treeData.indexOf(object);\r
- return expand(index);\r
- }\r
- \r
- @Override\r
- public boolean isCollapsed(T object) {\r
- int index = treeData.indexOf(object);\r
- return isCollapsed(index);\r
- }\r
- \r
-\r
- @SuppressWarnings("unchecked")\r
- public List<Integer> getChildIndexes(int parentIndex) {\r
- List<Integer> result = new ArrayList<Integer>();\r
- T t = this.treeData.getDataAtIndex(parentIndex);\r
- if (t == null)\r
- return Collections.EMPTY_LIST;\r
- List<T> children = this.treeData.getChildren(t);\r
- for (T child : children) {\r
- int index = this.treeData.indexOf(child);\r
- if (index >= 0) {\r
- result.add(index);\r
- result.addAll(getChildIndexes(index));\r
- } else {\r
- result.addAll(getChildIndexes(child));\r
- }\r
- }\r
- return result;\r
- }\r
- \r
- public List<Integer> getChildIndexes(T t) {\r
- List<Integer> result = new ArrayList<Integer>();\r
- List<T> children = this.treeData.getChildren(t);\r
- for (T child : children) {\r
- int index = this.treeData.indexOf(child);\r
- if (index >= 0) {\r
- result.add(index);\r
- result.addAll(getChildIndexes(index));\r
- } else {\r
- result.addAll(getChildIndexes(child));\r
- }\r
- }\r
- return result;\r
- }\r
- \r
- @SuppressWarnings("unchecked")\r
- public List<Integer> getExpandedChildIndexes(int parentIndex) {\r
- List<Integer> result = new ArrayList<Integer>();\r
- T t = this.treeData.getDataAtIndex(parentIndex);\r
- if (t == null)\r
- return Collections.EMPTY_LIST;\r
- List<T> children = this.treeData.getChildren(t);\r
- for (T child : children) {\r
- int index = this.treeData.indexOf(child);\r
- if (index >= 0) {\r
- result.add(index);\r
- if (expandedIndexes.contains(index))\r
- result.addAll(getExpandedChildIndexes(index));\r
- } else {\r
- result.addAll(getExpandedChildIndexes(child));\r
- }\r
- }\r
- return result;\r
- }\r
- \r
- public List<Integer> getExpandedChildIndexes(T t) {\r
- List<Integer> result = new ArrayList<Integer>();\r
- List<T> children = this.treeData.getChildren(t);\r
- for (T child : children) {\r
- int index = this.treeData.indexOf(child);\r
- if (index >= 0) {\r
- result.add(index);\r
- if (expandedIndexes.contains(index))\r
- result.addAll(getExpandedChildIndexes(index));\r
- } else {\r
- result.addAll(getExpandedChildIndexes(child));\r
- }\r
- }\r
- return result;\r
- }\r
- \r
- @Override\r
- public List<Integer> getDirectChildIndexes(int parentIndex) {\r
- List<Integer> result = new ArrayList<Integer>();\r
- T t = this.treeData.getDataAtIndex(parentIndex);\r
- if (t == null)\r
- return Collections.EMPTY_LIST;\r
- List<T> children = this.treeData.getChildren(t);\r
- for (T child : children) {\r
- int index = this.treeData.indexOf(child);\r
- if (index >= 0) {\r
- result.add(index);\r
- }\r
- }\r
- return result;\r
- }\r
- \r
- public ITreeData<T> getTreeData() {\r
- return treeData;\r
- }\r
-}\r
+package org.simantics.browsing.ui.nattable;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+
+import org.eclipse.nebula.widgets.nattable.tree.ITreeData;
+import org.eclipse.nebula.widgets.nattable.tree.ITreeRowModel;
+import org.eclipse.nebula.widgets.nattable.tree.ITreeRowModelListener;
+
+import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
+
+/**
+ * ITreeRowModel that does not automatically expand all child nodes (as TreeRowModel does).
+ *
+ * @author Marko Luukkainen <marko.luukkainen@vtt.fi>
+ *
+ * @param <T>
+ */
+public class GETreeRowModel<T> implements ITreeRowModel<T>{
+ //private final HashSet<Integer> parentIndexes = new HashSet<Integer>();
+ //private final TIntHashSet parentIndexes = new TIntHashSet(1000, 0.8f);
+ private final IntOpenHashSet expandedIndexes = new IntOpenHashSet();
+
+ private final Collection<ITreeRowModelListener> listeners = new HashSet<ITreeRowModelListener>();
+
+ private final ITreeData<T> treeData;
+
+ public GETreeRowModel(ITreeData<T> treeData) {
+ this.treeData = treeData;
+ }
+
+ public void registerRowGroupModelListener(ITreeRowModelListener listener) {
+ this.listeners.add(listener);
+ }
+
+ public void notifyListeners() {
+ for (ITreeRowModelListener listener : this.listeners) {
+ listener.treeRowModelChanged();
+ }
+ }
+
+ public int depth(int index) {
+ return this.treeData.getDepthOfData(this.treeData.getDataAtIndex(index));
+ }
+
+ public boolean isLeaf(int index) {
+ return !hasChildren(index);
+ }
+
+ public String getObjectAtIndexAndDepth(int index, int depth) {
+ return this.treeData.formatDataForDepth(depth,this.treeData.getDataAtIndex(index));
+ }
+
+ public boolean hasChildren(int index) {
+ return this.treeData.hasChildren(this.treeData.getDataAtIndex(index));
+ }
+
+ public boolean isCollapsed(int index) {
+ return !this.expandedIndexes.contains(index);
+ }
+
+ public void clear() {
+ this.expandedIndexes.clear();
+ }
+
+ @Override
+ public boolean isCollapsible(int index) {
+ return hasChildren(index);
+ }
+
+ @Override
+ public List<Integer> collapse(int index) {
+ this.expandedIndexes.remove(index);
+ notifyListeners();
+ List<Integer> list = getChildIndexes(index);
+ //this.parentIndexes.addAll(list);
+ return list;
+ }
+
+
+
+ @Override
+ public List<Integer> expand(int index) {
+ this.expandedIndexes.add(index);
+ notifyListeners();
+ List<Integer> children = getExpandedChildIndexes(index);
+ return children;
+ }
+
+ @Override
+ public List<Integer> collapseAll() {
+ return null;
+ }
+
+
+ @Override
+ public List<Integer> expandToLevel(int level) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public List<Integer> expandToLevel(T object, int level) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public List<Integer> expandAll() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public List<Integer> expandToLevel(int parentIndex, int level) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public List<T> getChildren(int parentIndex) {
+ T t = treeData.getDataAtIndex(parentIndex);
+ return treeData.getChildren(t,true);
+ }
+
+ @Override
+ public List<T> getDirectChildren(int parentIndex) {
+ return treeData.getChildren(parentIndex);
+ }
+
+
+ @Override
+ public List<Integer> collapse(T object) {
+ int index = treeData.indexOf(object);
+ return collapse(index);
+ }
+
+ @Override
+ public List<Integer> expand(T object) {
+ int index = treeData.indexOf(object);
+ return expand(index);
+ }
+
+ @Override
+ public boolean isCollapsed(T object) {
+ int index = treeData.indexOf(object);
+ return isCollapsed(index);
+ }
+
+
+ @SuppressWarnings("unchecked")
+ public List<Integer> getChildIndexes(int parentIndex) {
+ List<Integer> result = new ArrayList<Integer>();
+ T t = this.treeData.getDataAtIndex(parentIndex);
+ if (t == null)
+ return Collections.EMPTY_LIST;
+ List<T> children = this.treeData.getChildren(t);
+ for (T child : children) {
+ int index = this.treeData.indexOf(child);
+ if (index >= 0) {
+ result.add(index);
+ result.addAll(getChildIndexes(index));
+ } else {
+ result.addAll(getChildIndexes(child));
+ }
+ }
+ return result;
+ }
+
+ public List<Integer> getChildIndexes(T t) {
+ List<Integer> result = new ArrayList<Integer>();
+ List<T> children = this.treeData.getChildren(t);
+ for (T child : children) {
+ int index = this.treeData.indexOf(child);
+ if (index >= 0) {
+ result.add(index);
+ result.addAll(getChildIndexes(index));
+ } else {
+ result.addAll(getChildIndexes(child));
+ }
+ }
+ return result;
+ }
+
+ @SuppressWarnings("unchecked")
+ public List<Integer> getExpandedChildIndexes(int parentIndex) {
+ List<Integer> result = new ArrayList<Integer>();
+ T t = this.treeData.getDataAtIndex(parentIndex);
+ if (t == null)
+ return Collections.EMPTY_LIST;
+ List<T> children = this.treeData.getChildren(t);
+ for (T child : children) {
+ int index = this.treeData.indexOf(child);
+ if (index >= 0) {
+ result.add(index);
+ if (expandedIndexes.contains(index))
+ result.addAll(getExpandedChildIndexes(index));
+ } else {
+ result.addAll(getExpandedChildIndexes(child));
+ }
+ }
+ return result;
+ }
+
+ public List<Integer> getExpandedChildIndexes(T t) {
+ List<Integer> result = new ArrayList<Integer>();
+ List<T> children = this.treeData.getChildren(t);
+ for (T child : children) {
+ int index = this.treeData.indexOf(child);
+ if (index >= 0) {
+ result.add(index);
+ if (expandedIndexes.contains(index))
+ result.addAll(getExpandedChildIndexes(index));
+ } else {
+ result.addAll(getExpandedChildIndexes(child));
+ }
+ }
+ return result;
+ }
+
+ @Override
+ public List<Integer> getDirectChildIndexes(int parentIndex) {
+ List<Integer> result = new ArrayList<Integer>();
+ T t = this.treeData.getDataAtIndex(parentIndex);
+ if (t == null)
+ return Collections.EMPTY_LIST;
+ List<T> children = this.treeData.getChildren(t);
+ for (T child : children) {
+ int index = this.treeData.indexOf(child);
+ if (index >= 0) {
+ result.add(index);
+ }
+ }
+ return result;
+ }
+
+ public ITreeData<T> getTreeData() {
+ return treeData;
+ }
+}
Code Review / simantics / platform.git / blobdiff