-/*******************************************************************************\r
- * Copyright (c) 2012, 2013 Association for Decentralized Information Management in\r
- * Industry THTH ry.\r
- * All rights reserved. This program and the accompanying materials\r
- * are made available under the terms of the Eclipse Public License v1.0\r
- * which accompanies this distribution, and is available at\r
- * http://www.eclipse.org/legal/epl-v10.html\r
- *\r
- * Contributors:\r
- * VTT Technical Research Centre of Finland - initial API and implementation\r
- *******************************************************************************/\r
-package org.simantics.g3d.vtk.common;\r
-\r
-import java.util.ArrayList;\r
-import java.util.Collection;\r
-import java.util.List;\r
-\r
-import org.eclipse.jface.viewers.ISelection;\r
-import org.eclipse.jface.viewers.ISelectionChangedListener;\r
-import org.eclipse.jface.viewers.SelectionChangedEvent;\r
-import org.simantics.g3d.scenegraph.IG3DNode;\r
-import org.simantics.g3d.scenegraph.NodeHighlighter;\r
-import org.simantics.g3d.scenegraph.NodeHighlighter.HighlightEventType;\r
-import org.simantics.g3d.scenegraph.NodeHighlighter.HighlightObjectType;\r
-import org.simantics.g3d.scenegraph.base.INode;\r
-import org.simantics.g3d.tools.AdaptationUtils;\r
-import org.simantics.utils.threads.AWTThread;\r
-import org.simantics.utils.threads.ThreadUtils;\r
-\r
-import vtk.vtkActor;\r
-import vtk.vtkAlgorithm;\r
-import vtk.vtkAlgorithmOutput;\r
-import vtk.vtkFeatureEdges;\r
-import vtk.vtkMapper;\r
-import vtk.vtkPanel;\r
-import vtk.vtkProp;\r
-import vtk.vtkProperty;\r
-\r
-public class SelectionHighlighter implements ISelectionChangedListener{\r
-\r
- \r
- \r
- vtkPanel panel;\r
- VTKNodeMap nodeMap;\r
- \r
- List<IG3DNode> selectedNodes = new ArrayList<IG3DNode>();\r
- List<vtkActor> selectedActors = new ArrayList<vtkActor>();\r
- \r
- HighlightObjectType type = HighlightObjectType.Node;\r
- \r
- public SelectionHighlighter(vtkPanel panel, VTKNodeMap nodeMap) {\r
- this.panel = panel;\r
- this.nodeMap = nodeMap;\r
- }\r
- \r
- @Override\r
- public void selectionChanged(SelectionChangedEvent event) {\r
- final ISelection s = event.getSelection();\r
- \r
- if (Thread.currentThread().equals(AWTThread.getThreadAccess().getThread()))\r
- highlight(s);\r
- else {\r
- ThreadUtils.asyncExec(AWTThread.getThreadAccess(), new Runnable() {\r
- @Override\r
- public void run() {\r
- highlight(s);\r
- //System.out.println(this.getClass().getName() + " highlight ");\r
- panel.Render();\r
- //panel.repaint();\r
- }\r
- });\r
- }\r
- \r
- }\r
- \r
- protected void hilight(IG3DNode node, HighlightEventType type) {\r
- if (node instanceof NodeHighlighter) {\r
- ((NodeHighlighter)node).highlight(type);\r
- return;\r
- }\r
- if (type == HighlightEventType.Selection) {\r
- setSelectedColor(node); \r
- } else if (type == HighlightEventType.ClearSelection) {\r
- setDefaultColor(node);\r
- }\r
- }\r
- \r
- protected void hilight(vtkActor actor, HighlightEventType type) {\r
- if (type == HighlightEventType.Selection) {\r
- setColor(actor,false,new double[]{1,0,0});\r
- setColor(actor,true,new double[]{1,0,1});\r
- } else if (type == HighlightEventType.ClearSelection) {\r
- setColor(actor,false,new double[]{1,1,0});\r
- setColor(actor,true,new double[]{0,0,0});\r
- }\r
- }\r
- \r
- protected void highlight(ISelection s) {\r
- highlight(s, HighlightEventType.Selection, HighlightEventType.ClearSelection);\r
- }\r
- \r
- protected void highlight(ISelection s, HighlightEventType apply, HighlightEventType clear) {\r
- \r
- boolean changed = false;\r
- if (type == HighlightObjectType.Node) {\r
- Collection<IG3DNode> currentSelectedNodes = AdaptationUtils.adaptToCollection(s,IG3DNode.class);//getSelectedNodes(currentSelectedActors);\r
- if (currentSelectedNodes.size() == 0) {\r
- Collection<vtkProp> currentSelectedActors = AdaptationUtils.adaptToCollection(s, vtkProp.class);\r
- currentSelectedNodes = getSelectedNodes(currentSelectedActors);\r
- }\r
- for (IG3DNode node : selectedNodes) {\r
- if (!currentSelectedNodes.contains(node)) {\r
- hilight(node, clear);\r
- changed = true;\r
- }\r
- }\r
- for (IG3DNode node : currentSelectedNodes) {\r
- if (!selectedNodes.contains(node)) {\r
- hilight(node, apply);\r
- changed = true;\r
- }\r
- }\r
- selectedNodes.clear();\r
- selectedNodes.addAll(currentSelectedNodes);\r
- //selectedNodes = currentSelectedNodes;\r
- \r
- } else {\r
- \r
- Collection<vtkActor> currentSelectedActors = AdaptationUtils.adaptToCollection(s, vtkActor.class);\r
- \r
- for (vtkActor act : selectedActors) {\r
- if (!currentSelectedActors.contains(act)) {\r
- hilight(act,clear);\r
- changed = true;\r
- }\r
- }\r
- for (vtkActor act : currentSelectedActors) {\r
- if (!selectedActors.contains(act)) {\r
- hilight(act,apply);\r
- changed = true;\r
- }\r
- }\r
- selectedActors.clear();\r
- selectedActors.addAll(currentSelectedActors);\r
- }\r
- if (changed) {\r
- panel.repaint();\r
- }\r
- }\r
- \r
- protected List<IG3DNode> getSelectedNodes(Collection<vtkProp> selectedActors) {\r
- List<IG3DNode> currentSelectedNodes = new ArrayList<IG3DNode>();\r
- \r
- for (vtkProp a : selectedActors) {\r
- INode node = nodeMap.getNode((vtkProp)a);\r
- if (node == null || !(node instanceof IG3DNode))\r
- continue;\r
- if (!currentSelectedNodes.contains(node))\r
- currentSelectedNodes.add((IG3DNode)node);\r
- }\r
- return currentSelectedNodes;\r
- }\r
- \r
- protected void setDefaultColor(IG3DNode node) {\r
- double color[] = new double[]{1,1,0};\r
- setColor(node, false, color);\r
- }\r
- \r
- protected void setSelectedColor(IG3DNode node) {\r
- double color[] = new double[]{1,0,0};\r
- setColor(node, false, color);\r
- }\r
- \r
- \r
- protected void setColor(IG3DNode node, boolean edge, double color[]) {\r
- for (vtkProp prop : nodeMap.getRenderObjects(node)) {\r
- if (prop instanceof vtkActor) {\r
- vtkActor act = (vtkActor)prop;\r
- setColor(act, edge, color);\r
- }\r
- }\r
- }\r
- \r
- protected void setColor(vtkActor act, boolean edge, double color[]) {\r
- \r
- vtkMapper mapper = act.GetMapper();\r
- vtkAlgorithmOutput out = mapper.GetInputConnection(0, 0);\r
- vtkAlgorithm producer = out.GetProducer();\r
- boolean isEdge = (producer instanceof vtkFeatureEdges);\r
- producer.Delete();\r
- if (isEdge == edge) {\r
- vtkProperty property = act.GetProperty();\r
- property.SetColor(color);\r
- property.Delete();\r
- }\r
- out.Delete();\r
- mapper.Delete();\r
- }\r
-}\r
+/*******************************************************************************
+ * Copyright (c) 2012, 2013 Association for Decentralized Information Management in
+ * Industry THTH ry.
+ * 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:
+ * VTT Technical Research Centre of Finland - initial API and implementation
+ *******************************************************************************/
+package org.simantics.g3d.vtk.common;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.ISelectionChangedListener;
+import org.eclipse.jface.viewers.SelectionChangedEvent;
+import org.simantics.g3d.scenegraph.IG3DNode;
+import org.simantics.g3d.scenegraph.NodeHighlighter;
+import org.simantics.g3d.scenegraph.NodeHighlighter.HighlightEventType;
+import org.simantics.g3d.scenegraph.NodeHighlighter.HighlightObjectType;
+import org.simantics.g3d.scenegraph.base.INode;
+import org.simantics.g3d.tools.AdaptationUtils;
+import org.simantics.utils.threads.AWTThread;
+import org.simantics.utils.threads.ThreadUtils;
+
+import vtk.vtkActor;
+import vtk.vtkAlgorithm;
+import vtk.vtkAlgorithmOutput;
+import vtk.vtkFeatureEdges;
+import vtk.vtkMapper;
+import vtk.vtkPanel;
+import vtk.vtkProp;
+import vtk.vtkProperty;
+
+public class SelectionHighlighter<E extends IG3DNode> implements ISelectionChangedListener{
+
+
+
+ vtkPanel panel;
+ VTKNodeMap<E> nodeMap;
+
+ List<IG3DNode> selectedNodes = new ArrayList<IG3DNode>();
+ List<vtkActor> selectedActors = new ArrayList<vtkActor>();
+
+ HighlightObjectType type = HighlightObjectType.Node;
+
+ public SelectionHighlighter(vtkPanel panel, VTKNodeMap<E> nodeMap) {
+ this.panel = panel;
+ this.nodeMap = nodeMap;
+ }
+
+ @Override
+ public void selectionChanged(SelectionChangedEvent event) {
+ final ISelection s = event.getSelection();
+
+ if (Thread.currentThread().equals(AWTThread.getThreadAccess().getThread()))
+ highlight(s);
+ else {
+ ThreadUtils.asyncExec(AWTThread.getThreadAccess(), new Runnable() {
+ @Override
+ public void run() {
+ highlight(s);
+ //System.out.println(this.getClass().getName() + " highlight ");
+ panel.Render();
+ //panel.repaint();
+ }
+ });
+ }
+
+ }
+
+ protected void hilight(E node, HighlightEventType type) {
+ if (node instanceof NodeHighlighter) {
+ ((NodeHighlighter)node).highlight(type);
+ return;
+ }
+ if (type == HighlightEventType.Selection) {
+ setSelectedColor(node);
+ } else if (type == HighlightEventType.ClearSelection) {
+ setDefaultColor(node);
+ }
+ }
+
+ protected void hilight(vtkActor actor, HighlightEventType type) {
+ if (type == HighlightEventType.Selection) {
+ setColor(actor,false,new double[]{1,0,0});
+ setColor(actor,true,new double[]{1,0,1});
+ } else if (type == HighlightEventType.ClearSelection) {
+ setColor(actor,false,new double[]{1,1,0});
+ setColor(actor,true,new double[]{0,0,0});
+ }
+ }
+
+ protected void highlight(ISelection s) {
+ highlight(s, HighlightEventType.Selection, HighlightEventType.ClearSelection);
+ }
+
+ protected void highlight(ISelection s, HighlightEventType apply, HighlightEventType clear) {
+
+ boolean changed = false;
+ if (type == HighlightObjectType.Node) {
+ Collection<IG3DNode> currentSelectedNodes = AdaptationUtils.adaptToCollection(s,IG3DNode.class);//getSelectedNodes(currentSelectedActors);
+ if (currentSelectedNodes.size() == 0) {
+ Collection<vtkProp> currentSelectedActors = AdaptationUtils.adaptToCollection(s, vtkProp.class);
+ currentSelectedNodes = getSelectedNodes(currentSelectedActors);
+ }
+ for (IG3DNode node : selectedNodes) {
+ if (!currentSelectedNodes.contains(node)) {
+ hilight((E)node, clear);
+ changed = true;
+ }
+ }
+ for (IG3DNode node : currentSelectedNodes) {
+ if (!selectedNodes.contains(node)) {
+ hilight((E)node, apply);
+ changed = true;
+ }
+ }
+ selectedNodes.clear();
+ selectedNodes.addAll(currentSelectedNodes);
+ //selectedNodes = currentSelectedNodes;
+
+ } else {
+
+ Collection<vtkActor> currentSelectedActors = AdaptationUtils.adaptToCollection(s, vtkActor.class);
+
+ for (vtkActor act : selectedActors) {
+ if (!currentSelectedActors.contains(act)) {
+ hilight(act,clear);
+ changed = true;
+ }
+ }
+ for (vtkActor act : currentSelectedActors) {
+ if (!selectedActors.contains(act)) {
+ hilight(act,apply);
+ changed = true;
+ }
+ }
+ selectedActors.clear();
+ selectedActors.addAll(currentSelectedActors);
+ }
+ if (changed) {
+ panel.repaint();
+ }
+ }
+
+ protected List<IG3DNode> getSelectedNodes(Collection<vtkProp> selectedActors) {
+ List<IG3DNode> currentSelectedNodes = new ArrayList<IG3DNode>();
+
+ for (vtkProp a : selectedActors) {
+ INode node = nodeMap.getNode((vtkProp)a);
+ if (node == null || !(node instanceof IG3DNode))
+ continue;
+ if (!currentSelectedNodes.contains(node))
+ currentSelectedNodes.add((IG3DNode)node);
+ }
+ return currentSelectedNodes;
+ }
+
+ protected void setDefaultColor(E node) {
+ double color[] = new double[]{1,1,0};
+ setColor(node, false, color);
+ }
+
+ protected void setSelectedColor(E node) {
+ double color[] = new double[]{1,0,0};
+ setColor(node, false, color);
+ }
+
+
+ protected void setColor(E node, boolean edge, double color[]) {
+ for (vtkProp prop : nodeMap.getRenderObjects(node)) {
+ if (prop instanceof vtkActor) {
+ vtkActor act = (vtkActor)prop;
+ setColor(act, edge, color);
+ }
+ }
+ }
+
+ protected void setColor(vtkActor act, boolean edge, double color[]) {
+
+ vtkMapper mapper = act.GetMapper();
+ vtkAlgorithmOutput out = mapper.GetInputConnection(0, 0);
+ vtkAlgorithm producer = out.GetProducer();
+ boolean isEdge = (producer instanceof vtkFeatureEdges);
+ producer.Delete();
+ if (isEdge == edge) {
+ vtkProperty property = act.GetProperty();
+ property.SetColor(color);
+ property.Delete();
+ }
+ out.Delete();
+ mapper.Delete();
+ }
+}
Code Review / simantics / 3d.git / blobdiff