Add edge geometry for detailed rendering in closer zoom levels

[simantics/district.git] / org.simantics.district.network.ui / src / org / simantics / district / network / ui / adapters / DistrictNetworkVertexElement.java

diff --git a/org.simantics.district.network.ui/src/org/simantics/district/network/ui/adapters/DistrictNetworkVertexElement.java b/org.simantics.district.network.ui/src/org/simantics/district/network/ui/adapters/DistrictNetworkVertexElement.java
index 3e64bc3193957d249df2d6371cc5dfbcbc422d65..d873835c878bc14916d977153dad4379d09b05aa 100644 (file)
--- a/org.simantics.district.network.ui/src/org/simantics/district/network/ui/adapters/DistrictNetworkVertexElement.java
+++ b/org.simantics.district.network.ui/src/org/simantics/district/network/ui/adapters/DistrictNetworkVertexElement.java
@@ -1,18 +1,28 @@
 package org.simantics.district.network.ui.adapters;
 
+import java.awt.Color;
+import java.awt.Shape;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Rectangle2D;
 
+import org.simantics.diagram.elements.DiagramNodeUtil;
 import org.simantics.district.network.ui.nodes.DistrictNetworkVertexNode;
+import org.simantics.g2d.canvas.Hints;
+import org.simantics.g2d.canvas.ICanvasContext;
+import org.simantics.g2d.diagram.handler.PickRequest.PickPolicy;
 import org.simantics.g2d.element.ElementClass;
 import org.simantics.g2d.element.ElementUtils;
 import org.simantics.g2d.element.IElement;
 import org.simantics.g2d.element.SceneGraphNodeKey;
 import org.simantics.g2d.element.handler.InternalSize;
+import org.simantics.g2d.element.handler.Pick;
 import org.simantics.g2d.element.handler.SceneGraph;
 import org.simantics.g2d.element.handler.impl.DefaultTransform;
 import org.simantics.g2d.element.handler.impl.SimpleElementLayers;
+import org.simantics.scenegraph.INode;
 import org.simantics.scenegraph.g2d.G2DParentNode;
+import org.simantics.scenegraph.g2d.nodes.SVGNode;
+import org.simantics.scenegraph.utils.GeometryUtils;
 import org.simantics.utils.datastructures.hints.IHintContext.Key;
 import org.simantics.utils.datastructures.hints.IHintContext.KeyOf;
 
@@ -20,13 +30,15 @@ public class DistrictNetworkVertexElement {
 
     public static final Key KEY_DN_VERTEX = new KeyOf(DistrictNetworkVertex.class, "DN_VERTEX");
     public static final Key KEY_DN_VERTEX_NODE = new SceneGraphNodeKey(DistrictNetworkVertexNode.class, "DN_VERTEX_NODE");
+    public static final Key KEY_DN_VERTEX_SYMBOL_NODE = new SceneGraphNodeKey(SVGNode.class, "DN_VERTEX_SYMBOL_NODE");
     
     public static final ElementClass CLASS =
             ElementClass.compile(
                     DefaultTransform.INSTANCE,
                     DNVertexInternalSize.INSTANCE,
                     DNVertexSceneGraph.INSTANCE,
-                    SimpleElementLayers.INSTANCE
+                    SimpleElementLayers.INSTANCE,
+                    DistrictNetworkAdditionalColor.INSTANCE
             ).setId(DistrictNetworkVertexElement.class.getSimpleName());
     
     static final class DNVertexSceneGraph implements SceneGraph {
@@ -36,19 +48,25 @@ public class DistrictNetworkVertexElement {
         private static final long serialVersionUID = 8894367073815556871L;
 
         @Override
-        public void init(IElement edgeElement, G2DParentNode parent) {
-            DistrictNetworkVertex vertex = edgeElement.getHint(KEY_DN_VERTEX);
+        public void init(IElement vertexElement, G2DParentNode parent) {
+            DistrictNetworkVertex vertex = vertexElement.getHint(KEY_DN_VERTEX);
             if (vertex == null) {
-                cleanup(edgeElement);
+                cleanup(vertexElement);
             } else {
-                DistrictNetworkVertexNode node = edgeElement.getHint(KEY_DN_VERTEX_NODE);
+                DistrictNetworkVertexNode node = vertexElement.getHint(KEY_DN_VERTEX_NODE);
                 if (node == null) {
-                    node = parent.addNode(ElementUtils.generateNodeId(edgeElement), DistrictNetworkVertexNode.class);
-                    edgeElement.setHint(KEY_DN_VERTEX_NODE, node);
+                    node = parent.addNode(ElementUtils.generateNodeId(vertexElement), DistrictNetworkVertexNode.class);
+                    vertexElement.setHint(KEY_DN_VERTEX_NODE, node);
+                    
+                    SVGNode symbol = node.addNode(ElementUtils.generateNodeId(vertexElement), SVGNode.class);
+                    vertexElement.setHint(KEY_DN_VERTEX_SYMBOL_NODE, symbol);
                 }
+                
                 node.setVertex(vertex);
                 
-                AffineTransform at = ElementUtils.getTransform(edgeElement);
+                node.setColor(ElementUtils.getAdditionalColor(vertexElement, Color.BLUE));
+                
+                AffineTransform at = ElementUtils.getTransform(vertexElement);
                 if(at != null)
                     node.setTransform(at);
             }
@@ -56,12 +74,17 @@ public class DistrictNetworkVertexElement {
 
         @Override
         public void cleanup(IElement edge) {
-            ElementUtils.removePossibleNode(edge, KEY_DN_VERTEX_NODE);
+            ElementUtils.removePossibleNode(edge, KEY_DN_VERTEX_SYMBOL_NODE);
+            INode node = ElementUtils.removePossibleNode(edge, KEY_DN_VERTEX_NODE);
+            if (node != null)
+                node.getParent().remove();
+            
             edge.removeHint(KEY_DN_VERTEX_NODE);
+            edge.removeHint(KEY_DN_VERTEX_SYMBOL_NODE);
         }
     }
     
-    static final class DNVertexInternalSize implements InternalSize {
+    static final class DNVertexInternalSize implements InternalSize, Pick {
 
         public static final DNVertexInternalSize INSTANCE = new DNVertexInternalSize();
         
@@ -69,11 +92,48 @@ public class DistrictNetworkVertexElement {
 
         @Override
         public Rectangle2D getBounds(IElement e, Rectangle2D size) {
-            if (size == null)
-                size = new Rectangle2D.Double();
-            size.setFrame(-0.5, -0.5, 1, 1);
+            DistrictNetworkVertexNode node = e.getHint(KEY_DN_VERTEX_NODE);
+            Rectangle2D boundsInLocal = node.getBoundsInLocal();
+            ICanvasContext ctx = DiagramNodeUtil.getCanvasContext(node);
+            AffineTransform canvasTransform = ctx.getHintStack().getHint(Hints.KEY_CANVAS_TRANSFORM);
+            // for some reason PickContextImpl expands the rectangle by 0.001 (too much) - let's counter it
+            double counterExpansion = 0.001;
+            double x = boundsInLocal.getX() + counterExpansion;
+            double y = boundsInLocal.getY() + counterExpansion;
+            double scaledWidth = boundsInLocal.getWidth();
+            double scaledHeight = boundsInLocal.getHeight();
+            if (canvasTransform != null) {
+                scaledWidth = boundsInLocal.getWidth() / canvasTransform.getScaleX() / 10000.0;
+                scaledHeight= boundsInLocal.getHeight() / canvasTransform.getScaleY() / 10000.0;
+            }
+            double width = scaledWidth - 2*counterExpansion;
+            double height = scaledHeight - 2*counterExpansion;
+            size.setFrame(x, y, width, height);
+            
             return size;
         }
+
+        @Override
+        public boolean pickTest(IElement e, Shape s, PickPolicy policy) {
+            DistrictNetworkVertexNode node = e.getHint(KEY_DN_VERTEX_NODE);
+            Rectangle2D boundsInLocal = node.getBounds();
+            ICanvasContext ctx = DiagramNodeUtil.getCanvasContext(node);
+            AffineTransform canvasTransform = ctx.getHintStack().getHint(Hints.KEY_CANVAS_TRANSFORM);
+            Rectangle2D scaledBounds = new Rectangle2D.Double(boundsInLocal.getX(), boundsInLocal.getY(), boundsInLocal.getWidth() / canvasTransform.getScaleX() * 2, boundsInLocal.getHeight() / canvasTransform.getScaleY() * 2);
+            Rectangle2D bounds = getBounds(s);
+            switch (policy) {
+            case PICK_CONTAINED_OBJECTS:
+                return org.simantics.g2d.utils.GeometryUtils.contains(bounds, boundsInLocal);
+            case PICK_INTERSECTING_OBJECTS:
+                return org.simantics.g2d.utils.GeometryUtils.intersects(boundsInLocal, bounds);
+            }
+            return false;
+        }
         
+        private Rectangle2D getBounds(Shape shape) {
+            if (shape instanceof Rectangle2D)
+                return (Rectangle2D) shape;
+            return shape.getBounds2D();
+        }
     }
 }