]> gerrit.simantics Code Review - simantics/platform.git/commitdiff
Diagram to SVG enhancements 70/570/5
authorAntti Villberg <antti.villberg@semantum.fi>
Mon, 29 May 2017 12:06:26 +0000 (15:06 +0300)
committerTuukka Lehtonen <tuukka.lehtonen@semantum.fi>
Tue, 30 May 2017 05:38:18 +0000 (08:38 +0300)
refs #7253

Change-Id: I155f57928428f8ec4c39ffad90558396547dc10f

bundles/org.simantics.modeling.ui/src/org/simantics/modeling/ui/sg/DiagramSceneGraphProvider.java
bundles/org.simantics.modeling/src/org/simantics/modeling/SCLScenegraph.java
bundles/org.simantics.scenegraph/src/org/simantics/scenegraph/g2d/nodes/SelectionNode.java
bundles/org.simantics.scenegraph/src/org/simantics/scenegraph/g2d/nodes/connection/RouteGraphNode.java

index 3d800d1f1f43d56ff82c929f9e0fcc4aa12ea6fb..97d23f05f271f14214a6ec38e5382d407c5476aa 100644 (file)
@@ -244,7 +244,7 @@ public class DiagramSceneGraphProvider implements ICanvasSceneGraphProvider, IDi
         ctx.add( new ElementInteractor() );
         ctx.add( new Selection() );
         ctx.add( new DiagramParticipant() );
-        ctx.add( new ElementPainter(false) );
+        ctx.add( new ElementPainter(true) );
 
         //ctx.add( new ElementHeartbeater() );
         ctx.add( new ZOrderHandler() );
index 358d50fb4b4c9ac6f5f673ac3836bddf6f5ee383..5dde0b081677a9e41dac64ff7ea8c7934d789408 100644 (file)
@@ -1,5 +1,6 @@
 package org.simantics.modeling;
 
+import java.awt.BasicStroke;
 import java.awt.Dimension;
 import java.awt.RenderingHints;
 import java.awt.RenderingHints.Key;
@@ -36,6 +37,7 @@ import org.simantics.g2d.diagram.participant.Selection;
 import org.simantics.g2d.element.IElement;
 import org.simantics.g2d.scenegraph.ICanvasSceneGraphProvider;
 import org.simantics.g2d.utils.CanvasUtils;
+import org.simantics.scenegraph.INode;
 import org.simantics.scenegraph.ParentNode;
 import org.simantics.scenegraph.g2d.G2DParentNode;
 import org.simantics.scenegraph.g2d.G2DRenderingHints;
@@ -50,7 +52,9 @@ import org.simantics.scenegraph.g2d.nodes.DataNode;
 import org.simantics.scenegraph.g2d.nodes.DecorationSVGNode;
 import org.simantics.scenegraph.g2d.nodes.NavigationNode;
 import org.simantics.scenegraph.g2d.nodes.SVGNode;
+import org.simantics.scenegraph.g2d.nodes.SelectionNode;
 import org.simantics.scenegraph.g2d.nodes.SingleElementNode;
+import org.simantics.scenegraph.g2d.nodes.connection.RouteGraphNode;
 import org.simantics.scenegraph.g2d.nodes.spatial.RTreeNode;
 import org.simantics.scenegraph.utils.NodeUtil;
 import org.simantics.trend.impl.ItemNode;
@@ -443,10 +447,18 @@ public class SCLScenegraph {
                // Create an instance of the SVG Generator.
                SVGGraphics2D svgGenerator = new Generator(document);
 
-               StringBuilder b = new StringBuilder();
+               StringBuilder result = new StringBuilder();
 
                try {
 
+            Selection selection = ctx.getAtMostOneItemOfClass(Selection.class);
+            if (selection != null) {
+                // This prevents workbench selection from being left over.
+                // Also prevents scene graph crap from being left on the screen.
+               IDiagram d = ctx.getDefaultHintContext().getHint(DiagramHints.KEY_DIAGRAM);
+                selection.setSelection(0, d.getElements());
+            }
+
                        G2DSceneGraph sg = ctx.getSceneGraph();
                        G2DParentNode root = (G2DParentNode) sg.getRootNode();
 
@@ -481,69 +493,161 @@ public class SCLScenegraph {
                        double trX = -1 * content.getX();
                        double trY = -1 * content.getY();
 
-                       b.append("<svg width=\"100%\" height=\"100%\" stroke=\"black\"><g transform=\"translate(").append(trX).append(' ').append(trY).append(")\">");
+                       result.append("<svg width=\"100%\" height=\"100%\" stroke=\"black\"><g transform=\"translate(").append(trX).append(' ').append(trY).append(")\">");
 
                        IG2DNodeVisitor visitor = new IG2DNodeVisitor() {
 
                                int indent = 0;
 
-                               HashMap<IG2DNode,Integer> enters = new HashMap<>();
+                               HashMap<SingleElementNode,StringBuilder> senBuilders = new HashMap<>();
 
                                @Override
                                public void enter(IG2DNode node) {
+                                       
+                                       StringBuilder parentBuilder = getParentBuilder(node);
+                                       
                                        indent++;
                                        if(node instanceof ConnectionNode) {
+                                               
+                                               for(RouteGraphNode n : NodeUtil.collectNodes(node, RouteGraphNode.class)) {
+                                                       n.setIgnoreSelection(true);
+                                               }
+                                               
+                                               String key = ((ConnectionNode)node).getKey().toString();
+                                               
+                                               parentBuilder.append("\n<g class=\"connection\" id=\"" + key + "\">");
                                                Element doc = renderSVGNode((IG2DNode)node);
                                                String svg = printSVGDocument(doc);
-                                               b.append(svg);
+                                               parentBuilder.append(svg);
+
+                                               for(RouteGraphNode n : NodeUtil.collectNodes(node, RouteGraphNode.class)) {
+                                                       n.setIgnoreSelection(false);
+                                               }
+
+                                               parentBuilder.append("\n<g style=\"visibility:hidden\" class=\"selection\" id=\"" + key + "\">");
+                                               doc = renderSVGNode((IG2DNode)node);
+                                               svg = printSVGDocument(doc);
+                                               parentBuilder.append(svg);
+                                               parentBuilder.append("\n</g>");
+
+                                               BasicStroke bs = new BasicStroke(5f);
+                                               
+                                               for(RouteGraphNode n : NodeUtil.collectNodes(node, RouteGraphNode.class)) {
+                                                       n.setDynamicStroke(bs);
+                                               }
+
+                                               parentBuilder.append("\n<g class=\"selectionMask\" opacity=\"0.001\" id=\"" + key + "\">");
+                                               doc = renderSVGNode((IG2DNode)node);
+                                               svg = printSVGDocument(doc);
+                                               parentBuilder.append(svg);
+                                               parentBuilder.append("\n</g>");
+
+                                               parentBuilder.append("\n</g>");
+                                               
+                                       } else if (node instanceof SelectionNode) {
+                                               
+                                               SelectionNode n = (SelectionNode)node;
+                                               SingleElementNode parentSEN = (SingleElementNode)NodeUtil.getNearestParentOfType(node, SingleElementNode.class);
+                                               if(parentSEN != null && parentSEN.getKey() != null) {
+                                                       
+                                                       StringBuilder parentBuilder2 = getParentBuilder(parentSEN);
+                                                       
+                                                       String key = parentSEN.getKey().toString();
+                                                       Element doc = renderSVGNode((IG2DNode)node);
+                                                       String svg = printSVGDocument(doc);
+                                                       parentBuilder2.append("\n<g style=\"visibility:hidden\" class=\"selection\" id=\"" + key + "\">");
+                                                       parentBuilder2.append(svg);
+                                                       parentBuilder2.append("\n</g>");
+                                                       parentBuilder2.append("\n<g class=\"selectionMask\" id=\"" + key + "\">");
+                                                       Rectangle2D rect = n.getRect();
+                                                       parentBuilder2.append("<rect style=\"fill:#fff\" opacity=\"0.001\"");
+                                                       parentBuilder2.append(" x=\"" + rect.getX() + "\" y=\"" + rect.getY() + "\"");
+                                                       parentBuilder2.append(" width=\"" + rect.getWidth() + "\" height=\"" + rect.getHeight() + "\"");
+                                                       parentBuilder2.append("></rect>");
+                                                       parentBuilder2.append("\n</g>");
+                                               }
                                        } else if (node instanceof SVGNode) {
                                                SVGNode svg = (SVGNode)node;
-                                               b.append(svg.getSVGText());
+                                               parentBuilder.append(svg.getSVGText());
                                        } else if (node instanceof G2DParentNode) {
                                                AffineTransform at = node.getTransform();
                                                if(node instanceof SingleElementNode) {
                                                        SingleElementNode sen = (SingleElementNode)node;
                                                        if(sen.getKey() != null) {
                                                                String key = sen.getKey().toString();
-                                                               b.append("\n<g class=\"definedElement\" id=\"" + key + "\">");
+                                                               parentBuilder.append("\n<g class=\"definedElement\" id=\"" + key + "\">");
                                                        }
+                                                       senBuilders.put(sen, new StringBuilder());
                                                }
                                                if(!at.isIdentity()) {
                                                        if(at.getScaleX() == 1.0 && at.getScaleY() == 1.0 && at.getShearX() == 0.0 && at.getShearY() == 0.0) {
                                                                String m = "translate(" + at.getTranslateX() + " " + at.getTranslateY() + ")";
-                                                               b.append("\n<g transform=\"" + m + "\">");
+                                                               parentBuilder.append("\n<g transform=\"" + m + "\">");
                                                        } else {
                                                                double[] ds = new double[6];
                                                                at.getMatrix(ds);
                                                                String m = "matrix(" + ds[0] + " " + ds[1] + " " + ds[2] + " " + ds[3] + " " + ds[4] + " " + ds[5] + ")";
-                                                               b.append("\n<g transform=\"" + m + "\">");
+                                                               parentBuilder.append("\n<g transform=\"" + m + "\">");
                                                        }
                                                }
                                        }
 
-                                       enters.put(node, b.length());
+                                       //enters.put(node, b.length());
 
                                }
+                               
+                               private StringBuilder getParentBuilder(IG2DNode node) {
+                                       
+                                       INode parentSEN = NodeUtil.getNearestParentOfType(node, SingleElementNode.class);
+                                       if(parentSEN instanceof G2DSceneGraph) return result;
+
+                                       StringBuilder parentBuilder = senBuilders.get(parentSEN);
+                                       if(parentBuilder == null) return result;
+                                       
+                                       return parentBuilder;
+                                       
+                               }
 
                                @Override
                                public void leave(IG2DNode node) {
+
                                        if(node instanceof ConnectionNode || node instanceof SVGNode) {
                                                // We are done
                                        } else if (node instanceof G2DParentNode) {
+                                               
+                                               StringBuilder parentBuilder = getParentBuilder(node);
+                                               
+                                               if(node instanceof SingleElementNode) {
+                                                       SingleElementNode sen = (SingleElementNode)node;
+//                                                     if(sen.getKey() != null) {
+                                                               StringBuilder b = senBuilders.get(sen);
+                                                               String content = b.toString();
+                                                               if(content.isEmpty()) {
+                                                                       if(sen.getKey() != null) {
+                                                                               
+                                                                               for(SelectionNode n : NodeUtil.collectNodes(node, SelectionNode.class)) {
+                                                                                       n.setIgnore(true);
+                                                                               }
+
+                                                                               Element doc = renderSVGNode((IG2DNode)node);
+                                                                               String svg = printSVGDocument(doc);
+                                                                               parentBuilder.append(svg);
+                                                                       }
+                                                               } else {
+                                                                       parentBuilder.append(content);
+                                                               }
+//                                                     }
+                                               }
+
+                                               
                                                AffineTransform at = node.getTransform();
                                                if(!at.isIdentity()) {
-                                                       b.append("</g>");
+                                                       parentBuilder.append("</g>");
                                                }
                                                if(node instanceof SingleElementNode) {
                                                        SingleElementNode sen = (SingleElementNode)node;
                                                        if(sen.getKey() != null) {
-                                                               int enterLength = enters.get(node);
-                                                               if(b.length() == enterLength) {
-                                                                       Element doc = renderSVGNode((IG2DNode)node);
-                                                                       String svg = printSVGDocument(doc);
-                                                                       b.append(svg);
-                                                               }
-                                                               b.append("</g>");
+                                                               parentBuilder.append("</g>");
                                                        }
                                                }
                                        }
@@ -557,10 +661,10 @@ public class SCLScenegraph {
                        LOGGER.error("Problems rendering canvas context to SVG", t);
                }
 
-               b.append("</g></svg>");
+               result.append("</g></svg>");
                //System.err.println(" == FINAL RESULT == ");
                //System.err.println(b);
-               return b.toString();
+               return result.toString();
 
        }
 
index b5b8c4151fc7510a5c828bdbf36b5261b737e5e3..445a66fe3e9b5a7d431042c677f7323f12ee1ba5 100644 (file)
@@ -35,7 +35,12 @@ public class SelectionNode extends G2DNode implements Decoration {
     protected transient Rectangle2D rect;
     protected transient BasicStroke scaledStroke;
     protected transient double previousScaleRecip = Double.NaN;
+    private boolean ignore = false;
 
+    public void setIgnore(boolean value) {
+        ignore = value;
+    }
+  
     @SyncField({"transform", "bounds", "color"})
     public void init(AffineTransform transform, Rectangle2D bounds, Color color) {
         this.transform = transform;
@@ -46,6 +51,8 @@ public class SelectionNode extends G2DNode implements Decoration {
     @Override
     public void render(Graphics2D g) {
         if (bounds == null) return;
+        
+        if (ignore) return;
 
         // Prevent exceptions during rendering.
         if (transform.getDeterminant() == 0)
@@ -84,6 +91,10 @@ public class SelectionNode extends G2DNode implements Decoration {
         g.setTransform(ot);
 
     }
+    
+    public Rectangle2D getRect() {
+       return transform.createTransformedShape(rect).getBounds2D();
+    }
 
     @Override
     public Rectangle2D getBoundsInLocal() {
index 69268bad0644919f05032b7fdf84429d29bcbe37..687731f4c2f9d8528ab40cc0c6189151672828f4 100644 (file)
@@ -124,12 +124,22 @@ public class RouteGraphNode extends G2DNode implements ISelectionPainterNode, In
 
     protected transient Map<Object,ILineEndStyle> dynamicStyles = null;
     
+    private transient boolean ignoreSelection = false;
+    
     @Override
     public void initValues() {
         dynamicColor = null;
         wrapRenderer();
     }
 
+    public void setIgnoreSelection(boolean value) {
+        ignoreSelection = value;
+    }
+    
+    public boolean getIgnoreSelection() {
+        return ignoreSelection;
+    }  
+  
     @PropertySetter("color")
     @SyncField(value = {"dynamicColor"})
     public void setDynamicColor(Color color) {
@@ -347,7 +357,7 @@ public class RouteGraphNode extends G2DNode implements ISelectionPainterNode, In
         Object aaHint = g.getRenderingHint(RenderingHints.KEY_ANTIALIASING);
         g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
 
-        boolean selected = NodeUtil.isSelected(this, 1);
+        boolean selected = ignoreSelection ? false : NodeUtil.isSelected(this, 1);
 
         rg.updateTerminals();