bundles/org.simantics.modeling/src/org/simantics/modeling/SCLScenegraph.java

   1 package org.simantics.modeling;
   2
   3 import java.awt.Dimension;
   4 import java.awt.RenderingHints;
   5 import java.awt.RenderingHints.Key;
   6 import java.awt.geom.AffineTransform;
   7 import java.awt.geom.Rectangle2D;
   8 import java.io.ByteArrayOutputStream;
   9 import java.io.OutputStreamWriter;
  10 import java.util.ArrayList;
  11 import java.util.Collection;
  12 import java.util.HashMap;
  13 import java.util.List;
  14 import java.util.Set;
  15 import java.util.UUID;
  16
  17 import javax.xml.transform.OutputKeys;
  18 import javax.xml.transform.Transformer;
  19 import javax.xml.transform.TransformerFactory;
  20 import javax.xml.transform.dom.DOMSource;
  21 import javax.xml.transform.stream.StreamResult;
  22
  23 import org.apache.batik.dom.GenericDOMImplementation;
  24 import org.apache.batik.svggen.SVGGeneratorContext;
  25 import org.apache.batik.svggen.SVGGraphics2D;
  26 import org.simantics.db.Resource;
  27 import org.simantics.db.exception.DatabaseException;
  28 import org.simantics.diagram.elements.DiagramNodeUtil;
  29 import org.simantics.diagram.elements.TextGridNode;
  30 import org.simantics.diagram.elements.TextNode;
  31 import org.simantics.g2d.canvas.ICanvasContext;
  32 import org.simantics.g2d.diagram.DiagramHints;
  33 import org.simantics.g2d.diagram.IDiagram;
  34 import org.simantics.g2d.diagram.handler.DataElementMap;
  35 import org.simantics.g2d.diagram.participant.Selection;
  36 import org.simantics.g2d.element.IElement;
  37 import org.simantics.g2d.scenegraph.ICanvasSceneGraphProvider;
  38 import org.simantics.g2d.utils.CanvasUtils;
  39 import org.simantics.scenegraph.ParentNode;
  40 import org.simantics.scenegraph.g2d.G2DParentNode;
  41 import org.simantics.scenegraph.g2d.G2DRenderingHints;
  42 import org.simantics.scenegraph.g2d.G2DSceneGraph;
  43 import org.simantics.scenegraph.g2d.IG2DNode;
  44 import org.simantics.scenegraph.g2d.IG2DNodeVisitor;
  45 import org.simantics.scenegraph.g2d.events.command.Commands;
  46 import org.simantics.scenegraph.g2d.nodes.BackgroundNode;
  47 import org.simantics.scenegraph.g2d.nodes.BoundsNode;
  48 import org.simantics.scenegraph.g2d.nodes.ConnectionNode;
  49 import org.simantics.scenegraph.g2d.nodes.DataNode;
  50 import org.simantics.scenegraph.g2d.nodes.DecorationSVGNode;
  51 import org.simantics.scenegraph.g2d.nodes.NavigationNode;
  52 import org.simantics.scenegraph.g2d.nodes.SVGNode;
  53 import org.simantics.scenegraph.g2d.nodes.SingleElementNode;
  54 import org.simantics.scenegraph.g2d.nodes.spatial.RTreeNode;
  55 import org.simantics.scenegraph.utils.NodeUtil;
  56 import org.simantics.trend.impl.ItemNode;
  57 import org.simantics.utils.threads.ThreadUtils;
  58 import org.slf4j.Logger;
  59 import org.slf4j.LoggerFactory;
  60 import org.w3c.dom.DOMImplementation;
  61 import org.w3c.dom.Document;
  62 import org.w3c.dom.Element;
  63 import org.w3c.dom.NodeList;
  64
  65 public class SCLScenegraph {
  66
  67         private static final Logger LOGGER = LoggerFactory.getLogger(SCLScenegraph.class);
  68
  69         public static ICanvasSceneGraphProvider getICanvasSceneGraphProvider(Resource model, Resource diagram, String diagramRVI) throws DatabaseException, InterruptedException {
  70                 ICanvasSceneGraphProvider provider = DiagramNodeUtil.loadSceneGraphProvider(model, diagram, diagramRVI);
  71                 return provider;
  72         }
  73
  74         public static void disposeSceneGraphProvider(ICanvasSceneGraphProvider provider) {
  75                 provider.dispose();
  76         }
  77
  78         public static String getNodeTransform(ICanvasContext ctx, String name) {
  79
  80                 Set<TextNode> texts = NodeUtil.collectNodes(ctx.getSceneGraph(), TextNode.class);
  81                 for (TextNode text : texts) {
  82                         String nodeName = NodeUtil.getNodeName(text);
  83                         if (nodeName.equals(name)) {
  84                                 String transform = text.getTransform().toString();
  85                                 return transform;
  86                         }
  87                 }
  88                 return "No node found";
  89         }
  90
  91         public static String getNodeText(ICanvasContext ctx, String name) {
  92
  93                 Set<TextNode> texts = NodeUtil.collectNodes(ctx.getSceneGraph(), TextNode.class);
  94                 for (TextNode text : texts) {
  95                         String nodeName = NodeUtil.getNodeName(text);
  96                         if (nodeName.equals(name)) {
  97                                 String texti = text.getText();
  98                                 return texti;
  99                         }
 100                 }
 101                 return "No node found";
 102         }
 103
 104         public static String getNodeCount(ICanvasContext ctx) {
 105                 G2DSceneGraph g2 = ctx.getSceneGraph();
 106                 int amount = NodeUtil.countTreeNodes(g2);
 107                 return "Node count: " + amount;
 108         }
 109
 110     public static String getAllNodes (ICanvasContext ctx) {
 111
 112         Set<G2DSceneGraph> g2 = NodeUtil.collectNodes(ctx.getSceneGraph(), G2DSceneGraph.class);
 113         int amount = g2.size() +1;
 114         return "All nodes: " + amount;
 115     }
 116
 117     public static String getBoundsNodes (ICanvasContext ctx) {
 118
 119         Set<BoundsNode> bn = NodeUtil.collectNodes(ctx.getSceneGraph(), BoundsNode.class);
 120         int amount = bn.size();
 121         return "BoundsNodes: " + amount;
 122     }
 123
 124     public static String getBackgroundNodes (ICanvasContext ctx) {
 125
 126         Set<BackgroundNode> bg = NodeUtil.collectNodes(ctx.getSceneGraph(), BackgroundNode.class);
 127         int amount = bg.size();
 128         return "BackgroundNodes: " + amount;
 129     }
 130
 131     public static String getDataNodes (ICanvasContext ctx) {
 132
 133         Set<DataNode> dn = NodeUtil.collectNodes(ctx.getSceneGraph(), DataNode.class);
 134         int amount = dn.size();
 135         return "DataNodes: " + amount;
 136     }
 137
 138     public static String getNavigationNodes (ICanvasContext ctx) {
 139
 140         Set<NavigationNode> g2 = NodeUtil.collectNodes(ctx.getSceneGraph(), NavigationNode.class);
 141         int amount = g2.size();
 142         return "NavigationNodes: " + amount;
 143     }
 144
 145     public static String getParentNodes (ICanvasContext ctx) {
 146
 147         Set<G2DParentNode> g2 = NodeUtil.collectNodes(ctx.getSceneGraph(), G2DParentNode.class);
 148         int amount = g2.size();
 149         return "ParentNodes: " + amount;
 150     }
 151
 152     public static String getDecorationNodes (ICanvasContext ctx) {
 153
 154         Set<DecorationSVGNode> deco = NodeUtil.collectNodes(ctx.getSceneGraph(), DecorationSVGNode.class);
 155         int amount = deco.size();
 156         return "DecorationNodes: " + amount;
 157     }
 158
 159     public static String getSingleElementNodes (ICanvasContext ctx) {
 160
 161         Set<SingleElementNode> g2 = NodeUtil.collectNodes(ctx.getSceneGraph(), SingleElementNode.class);
 162         int amount = g2.size();
 163         return "SingleElementNodes: " + amount;
 164     }
 165
 166     public static String getConnectionNodes (ICanvasContext ctx) {
 167
 168         Set<ConnectionNode> g2 = NodeUtil.collectNodes(ctx.getSceneGraph(), ConnectionNode.class);
 169         int amount = g2.size();
 170         return "ConnectionNodes: " + amount;
 171     }
 172
 173     public static String getTextNodes (ICanvasContext ctx) {
 174
 175         Set<TextNode> tn = NodeUtil.collectNodes(ctx.getSceneGraph(), TextNode.class);
 176         Set<TextGridNode> tgn = NodeUtil.collectNodes(ctx.getSceneGraph(), TextGridNode.class);
 177         int amount = tn.size() + tgn.size();
 178         return "TextNodes: " + amount;
 179     }
 180
 181     public static String getItemNodes (ICanvasContext ctx) {
 182
 183         Set<ItemNode> item = NodeUtil.collectNodes(ctx.getSceneGraph(), ItemNode.class);
 184         int amount = item.size();
 185         return "ItemNodes: " + amount;
 186     }
 187
 188     public static String editNodeText (ICanvasContext ctx, String module, String previous_value, String new_value) {
 189
 190         Set<TextNode> textGridNodes = NodeUtil.collectNodes(ctx.getSceneGraph(), TextNode.class);
 191         for (TextNode modulenode : textGridNodes) {
 192                 if (module.equals(modulenode.getText())) {
 193                         //System.out.println("Module what we were looking for: " + module);
 194                         //System.out.println("Modulenode: " + modulenode.getText());
 195
 196                         ParentNode<?> parentnode = modulenode.getParent();
 197                         //System.out.println("Parentnode: " + parentnode);
 198
 199                         Collection<TextNode> textnodes = (Collection<TextNode>) parentnode.getNodes();
 200                         for (TextNode valuenode : textnodes) {
 201                                 if (previous_value.equals(valuenode.getText())) {
 202                                         //System.out.println("Value what we were looking for: " + previous_value);
 203                                         //System.out.println("Valuenode: " + valuenode.getText());
 204
 205                                         //valuenode.setEditMode(true);
 206                                         valuenode.activateEdit(0, null, ctx);
 207                                         valuenode.setText(new_value);
 208                                         valuenode.fireTextEditingEnded();
 209
 210                                         //System.out.println("valuenode modified: " + valuenode);
 211                                         return "Modified module " + module + " with value " + new_value;
 212                                 }
 213                         }
 214                         return "Not found module : " + module;
 215                 }
 216         }
 217         return "No nodes in scenegraph!";
 218     }
 219
 220     public static String sceneGraphTest (ICanvasContext ctx, String module, String value) {
 221
 222         boolean module_founded = false;
 223         boolean value_founded = false;
 224
 225         Set<G2DSceneGraph> g2 = NodeUtil.collectNodes(ctx.getSceneGraph(), G2DSceneGraph.class);
 226         System.out.println("Total amount of nodes: " + g2.size() + 1);
 227
 228         Set<TextGridNode> grid = NodeUtil.collectNodes(ctx.getSceneGraph(), TextGridNode.class);
 229         Integer textGridNodeAmount = grid.size();
 230         System.out.println("Amount of TextGridNodes " + textGridNodeAmount);
 231
 232         Set<TextNode> texts = NodeUtil.collectNodes(ctx.getSceneGraph(), TextNode.class);
 233         Integer textNodeAmount = grid.size();
 234         System.out.println("Amount of TextNodes " + textNodeAmount);
 235
 236         for (TextNode node : texts) {
 237             if (module.equals(node.getText())) {
 238                 module_founded = true;
 239                 System.out.println("Correct module " + module + " founded.");
 240             }
 241             if (value.equals(node.getText())) {
 242                 value_founded = true;
 243                 System.out.println("Correct value " + value + " founded.");
 244             }
 245         }
 246
 247         if (value_founded == true && module_founded == true) {
 248                 return "Found both correct module " + module + " and value " + value;
 249         }
 250         if (value_founded == false && module_founded == true) {
 251                 return "Found only correct module " + module + " but not value " + value;
 252         }
 253         if (value_founded == true && module_founded == false) {
 254                 return "Found only correct value " + value + " but not module " + module;
 255         }
 256         else {
 257                 return "Didn't found either module " + module + " or value " + value;
 258         }
 259     }
 260
 261     public static boolean copyPaste (final ICanvasContext source_ctx, final ICanvasContext target_ctx, List<Resource> modules) throws DatabaseException {
 262
 263         IDiagram idiagram = source_ctx.getDefaultHintContext().getHint(DiagramHints.KEY_DIAGRAM);
 264
 265                 DataElementMap dem = idiagram.getDiagramClass().getAtMostOneItemOfClass(DataElementMap.class);
 266                 if (dem != null) {
 267                         final Collection<IElement> newSelection = new ArrayList<IElement>();
 268                         for (Resource module : modules) {
 269                                 IElement element = dem.getElement(idiagram, module);
 270                                 if (element != null) {
 271                                         newSelection.add(element);
 272                                 } else {
 273                                         throw new DatabaseException("Could not find IElement for " + element);
 274                                 }
 275                         }
 276
 277                         ThreadUtils.syncExec(source_ctx.getThreadAccess(), new Runnable() {
 278                     @Override
 279                     public void run() {
 280                         if (source_ctx.isDisposed())
 281                             return;
 282                         Selection selection = source_ctx.getAtMostOneItemOfClass(Selection.class);
 283                         if (selection != null) {
 284                             // This prevents workbench selection from being left over.
 285                             // Also prevents scene graph crap from being left on the screen.
 286                             selection.setSelection(0, newSelection);
 287                         }
 288                                 CanvasUtils.sendCommand(source_ctx, Commands.COPY);
 289                                 CanvasUtils.sendCommand(target_ctx, Commands.PASTE);
 290                     }
 291                 });
 292
 293                 //}
 294
 295                 while(source_ctx.getEventQueue().size() > 0) {
 296                         try {
 297                                 Thread.sleep(10);
 298                         } catch (InterruptedException e) {
 299                                 throw new DatabaseException(e);
 300                         }
 301                 }
 302
 303                 ThreadUtils.syncExec(source_ctx.getThreadAccess(), new Runnable() {
 304             @Override
 305             public void run() {
 306             }
 307         });
 308
 309                 }
 310                 return true;
 311     }
 312
 313         static class Generator extends SVGGraphics2D {
 314
 315                 int elemLevel = 0;
 316                 String newElementId = null;
 317                 ArrayList<Element> elements = new ArrayList<Element>();
 318
 319                 public static final String svgNS = "http://www.w3.org/2000/svg";
 320
 321                 public Generator(SVGGeneratorContext ctx, boolean joku) {
 322                         super(ctx, joku);
 323                 }
 324
 325                 public Generator(Document document) {
 326                         super(document);
 327                 }
 328
 329                 @Override
 330                 public Element getRoot() {
 331                         Element root = super.getRoot();
 332                         for(Element e : elements) {
 333                                 root.appendChild(e);
 334                         }
 335                         return root;
 336                 }
 337
 338                 @Override
 339                 public void setRenderingHint(Key arg0, Object arg1) {
 340                         if(G2DRenderingHints.KEY_BEGIN_ELEMENT == arg0) {
 341                                 elemLevel++;
 342                         }
 343                         if(G2DRenderingHints.KEY_ELEMENT_ID == arg0) {
 344                                 if(arg1 != null)
 345                                         newElementId = arg1.toString();
 346                                 else
 347                                         newElementId = UUID.randomUUID().toString();
 348                         }
 349                         if(G2DRenderingHints.KEY_END_ELEMENT == arg0) {
 350                                 elemLevel--;
 351                                 if(elemLevel == 0) {
 352                                         Element group = getDOMFactory().createElement(SVG_G_TAG);
 353                                         //Element group = getDOMFactory().createElementNS(SVG_NAMESPACE_URI, SVG_G_TAG);
 354                                         group.setAttributeNS(null, "id", newElementId);
 355                                         group.setAttributeNS(null, "class", arg1.toString());
 356                                         getRoot(group);
 357                                         elements.add(group);
 358                                 }
 359                         }
 360                         super.setRenderingHint(arg0, arg1);
 361                 }
 362
 363         }
 364
 365         public static Element renderSVGNode(IG2DNode node) {
 366
 367                 // Get a DOMImplementation.
 368                 DOMImplementation domImpl = GenericDOMImplementation.getDOMImplementation();
 369
 370                 // Create an instance of org.w3c.dom.Document.
 371                 String svgNS = "http://www.w3.org/2000/svg";
 372                 Document document = domImpl.createDocument(svgNS, "svg", null);
 373
 374                 SVGGeneratorContext ctx = SVGGeneratorContext.createDefault(document);
 375                 ctx.setComment(null);
 376
 377                 // Create an instance of the SVG Generator.
 378                 SVGGraphics2D svgGenerator = new Generator(ctx, false);
 379
 380                 try {
 381
 382                         svgGenerator.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
 383                         svgGenerator.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
 384                         svgGenerator.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
 385
 386                         node.render(svgGenerator);
 387
 388                 } catch (Throwable t) {
 389                         LOGGER.error("Problems rendering scene graph to SVG", t);
 390                 }
 391
 392                 return svgGenerator.getRoot();
 393         }
 394
 395         public static String printSVGDocument(Element doce) {
 396
 397                 StringBuilder result = new StringBuilder();
 398
 399                 NodeList nl =  doce.getChildNodes();
 400
 401                 for(int i=0;i<nl.getLength();i++) {
 402
 403                         ByteArrayOutputStream os = new ByteArrayOutputStream();
 404
 405                         try {
 406
 407                                 TransformerFactory tf = TransformerFactory.newInstance();
 408                                 Transformer transformer = tf.newTransformer();
 409                                 transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
 410                                 transformer.setOutputProperty(OutputKeys.STANDALONE, "no");
 411                                 transformer.setOutputProperty(OutputKeys.METHOD, "xml");
 412                                 transformer.setOutputProperty(OutputKeys.INDENT, "yes");
 413                                 transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
 414                                 transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");
 415
 416                                 transformer.transform(new DOMSource(nl.item(i)),
 417                                                 new StreamResult(new OutputStreamWriter(os, "UTF-8")));
 418
 419                                 os.flush();
 420                                 os.close();
 421
 422                         } catch (Throwable t) {
 423                                 LOGGER.error("Problems formatting SVGDocument to text.", t);
 424                         }
 425
 426                         result.append(new String(os.toByteArray()));
 427
 428                 }
 429
 430                 return result.toString();
 431
 432         }
 433
 434         public static String renderSVG(ICanvasContext ctx) {
 435
 436                 // Get a DOMImplementation.
 437                 DOMImplementation domImpl = GenericDOMImplementation.getDOMImplementation();
 438
 439                 // Create an instance of org.w3c.dom.Document.
 440                 String svgNS = "http://www.w3.org/2000/svg";
 441                 Document document = domImpl.createDocument(svgNS, "svg", null);
 442
 443                 // Create an instance of the SVG Generator.
 444                 SVGGraphics2D svgGenerator = new Generator(document);
 445
 446                 StringBuilder b = new StringBuilder();
 447
 448                 try {
 449
 450                         G2DSceneGraph sg = ctx.getSceneGraph();
 451                         G2DParentNode root = (G2DParentNode) sg.getRootNode();
 452
 453                         // rtree is the actual content of the diagram
 454                         RTreeNode rtree = NodeUtil.getNearestChildByClass(root, RTreeNode.class);
 455                         Rectangle2D rtreeBounds = NodeUtil.getLocalBounds(rtree);
 456
 457                         // nav is a node that has zooming functionalities
 458                         NavigationNode nav = NodeUtil.getNearestChildByClass(root, NavigationNode.class);
 459                         nav.setZoomEnabled(true);
 460
 461                         // fit view with the contents of rtreeBounds
 462                         nav.zoomTo(rtreeBounds);
 463
 464                         // get the bounds of the content
 465                         Rectangle2D content = NodeUtil.getLocalBounds(nav);
 466
 467                         svgGenerator.scale(3,3);
 468
 469                         // translate svgGenerator to the x and y coordinates of current content
 470                         svgGenerator.translate(-1 * content.getX(), (-1 * content.getY()));
 471
 472                         Rectangle2D destination = new Rectangle2D.Double(0,0,1000,1000);
 473                         double sx = destination.getWidth() / content.getWidth();
 474                         double sy = destination.getHeight() / content.getHeight();
 475                         double scale = sx < sy ? sx : sy;
 476
 477                         // Set svgCanvasSize to the given size parameters
 478                         svgGenerator.setSVGCanvasSize(new Dimension((int)(scale * content.getWidth()), (int)(scale * content.getHeight())));
 479                         svgGenerator.setClip(content);
 480
 481                         double trX = -1 * content.getX();
 482                         double trY = -1 * content.getY();
 483
 484                         b.append("<svg width=\"100%\" height=\"100%\" stroke=\"black\"><g transform=\"translate(").append(trX).append(' ').append(trY).append(")\">");
 485
 486                         IG2DNodeVisitor visitor = new IG2DNodeVisitor() {
 487
 488                                 int indent = 0;
 489
 490                                 HashMap<IG2DNode,Integer> enters = new HashMap<>();
 491
 492                                 @Override
 493                                 public void enter(IG2DNode node) {
 494                                         indent++;
 495                                         if(node instanceof ConnectionNode) {
 496                                                 Element doc = renderSVGNode((IG2DNode)node);
 497                                                 String svg = printSVGDocument(doc);
 498                                                 b.append(svg);
 499                                         } else if (node instanceof SVGNode) {
 500                                                 SVGNode svg = (SVGNode)node;
 501                                                 b.append(svg.getSVGText());
 502                                         } else if (node instanceof G2DParentNode) {
 503                                                 AffineTransform at = node.getTransform();
 504                                                 if(node instanceof SingleElementNode) {
 505                                                         SingleElementNode sen = (SingleElementNode)node;
 506                                                         if(sen.getKey() != null) {
 507                                                                 String key = sen.getKey().toString();
 508                                                                 b.append("\n<g class=\"definedElement\" id=\"" + key + "\">");
 509                                                         }
 510                                                 }
 511                                                 if(!at.isIdentity()) {
 512                                                         if(at.getScaleX() == 1.0 && at.getScaleY() == 1.0 && at.getShearX() == 0.0 && at.getShearY() == 0.0) {
 513                                                                 String m = "translate(" + at.getTranslateX() + " " + at.getTranslateY() + ")";
 514                                                                 b.append("\n<g transform=\"" + m + "\">");
 515                                                         } else {
 516                                                                 double[] ds = new double[6];
 517                                                                 at.getMatrix(ds);
 518                                                                 String m = "matrix(" + ds[0] + " " + ds[1] + " " + ds[2] + " " + ds[3] + " " + ds[4] + " " + ds[5] + ")";
 519                                                                 b.append("\n<g transform=\"" + m + "\">");
 520                                                         }
 521                                                 }
 522                                         }
 523
 524                                         enters.put(node, b.length());
 525
 526                                 }
 527
 528                                 @Override
 529                                 public void leave(IG2DNode node) {
 530                                         if(node instanceof ConnectionNode || node instanceof SVGNode) {
 531                                                 // We are done
 532                                         } else if (node instanceof G2DParentNode) {
 533                                                 AffineTransform at = node.getTransform();
 534                                                 if(!at.isIdentity()) {
 535                                                         b.append("</g>");
 536                                                 }
 537                                                 if(node instanceof SingleElementNode) {
 538                                                         SingleElementNode sen = (SingleElementNode)node;
 539                                                         if(sen.getKey() != null) {
 540                                                                 int enterLength = enters.get(node);
 541                                                                 if(b.length() == enterLength) {
 542                                                                         Element doc = renderSVGNode((IG2DNode)node);
 543                                                                         String svg = printSVGDocument(doc);
 544                                                                         b.append(svg);
 545                                                                 }
 546                                                                 b.append("</g>");
 547                                                         }
 548                                                 }
 549                                         }
 550                                         indent --;
 551                                 }
 552
 553                         };
 554                         sg.accept(visitor);
 555
 556                 } catch (Throwable t) {
 557                         LOGGER.error("Problems rendering canvas context to SVG", t);
 558                 }
 559
 560                 b.append("</g></svg>");
 561                 //System.err.println(" == FINAL RESULT == ");
 562                 //System.err.println(b);
 563                 return b.toString();
 564
 565         }
 566
 567
 568 }