More robustness fixes for editing of texts inside SVG elements.
[simantics/platform.git] / bundles / org.simantics.scenegraph / src / org / simantics / scenegraph / utils / NodeUtil.java
1 /*******************************************************************************
2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management
3  * in Industry THTH ry.
4  * All rights reserved. This program and the accompanying materials
5  * are made available under the terms of the Eclipse Public License v1.0
6  * which accompanies this distribution, and is available at
7  * http://www.eclipse.org/legal/epl-v10.html
8  *
9  * Contributors:
10  *     VTT Technical Research Centre of Finland - initial API and implementation
11  *******************************************************************************/
12 package org.simantics.scenegraph.utils;
13
14 import java.awt.AWTEvent;
15 import java.awt.Container;
16 import java.awt.event.MouseEvent;
17 import java.awt.event.MouseWheelEvent;
18 import java.awt.geom.AffineTransform;
19 import java.awt.geom.NoninvertibleTransformException;
20 import java.awt.geom.Point2D;
21 import java.awt.geom.Rectangle2D;
22 import java.io.PrintStream;
23 import java.lang.reflect.InvocationTargetException;
24 import java.lang.reflect.Method;
25 import java.util.ArrayList;
26 import java.util.Collection;
27 import java.util.HashSet;
28 import java.util.Iterator;
29 import java.util.List;
30 import java.util.Set;
31 import java.util.concurrent.TimeUnit;
32 import java.util.concurrent.locks.Condition;
33 import java.util.concurrent.locks.Lock;
34 import java.util.concurrent.locks.ReentrantLock;
35 import java.util.function.Function;
36
37 import org.simantics.scenegraph.IDynamicSelectionPainterNode;
38 import org.simantics.scenegraph.ILookupService;
39 import org.simantics.scenegraph.INode;
40 import org.simantics.scenegraph.INode.PropertySetter;
41 import org.simantics.scenegraph.ISelectionPainterNode;
42 import org.simantics.scenegraph.ParentNode;
43 import org.simantics.scenegraph.g2d.G2DParentNode;
44 import org.simantics.scenegraph.g2d.G2DSceneGraph;
45 import org.simantics.scenegraph.g2d.IG2DNode;
46 import org.simantics.scenegraph.g2d.events.EventDelegator;
47 import org.simantics.scenegraph.g2d.events.NodeEventHandler;
48 import org.simantics.scenegraph.g2d.events.SGMouseEvent;
49 import org.simantics.scenegraph.g2d.events.SGMouseWheelEvent;
50 import org.simantics.scenegraph.g2d.nodes.ConnectionNode;
51 import org.simantics.scenegraph.g2d.nodes.FlagNode;
52 import org.simantics.scenegraph.g2d.nodes.SingleElementNode;
53 import org.simantics.scl.runtime.function.Function1;
54 import org.simantics.scl.runtime.function.FunctionImpl1;
55 import org.simantics.utils.datastructures.Pair;
56 import org.simantics.utils.threads.IThreadWorkQueue;
57
58 /**
59  * Utilities for debugging/printing the contents of a scenegraph.
60  * 
61  * @author Tuukka Lehtonen
62  */
63 public final class NodeUtil {
64
65     /**
66      * @param <T>
67      */
68     public static interface Filter<T> {
69         public boolean accept(T t);
70     }
71
72     public static class PrefixFilter implements Filter<String> {
73         private final String prefix;
74         public PrefixFilter(String prefix) {
75             this.prefix = prefix;
76         }
77         @Override
78         public boolean accept(String t) {
79             return t.startsWith(prefix);
80         }
81     }
82
83     /**
84      * The name of the sibling-node that is used to represent that a node is selected.
85      */
86     public static final String SELECTION_NODE_NAME = "selection";
87
88     public static INode getNearestParentOfType(INode node, Class<?> clazz) {
89         ParentNode<?> parent = null;
90         while (true) {
91             parent = node.getParent();
92             if (parent == null)
93                 return node;
94             node = parent;
95             if (clazz.isInstance(node))
96                 return node;
97         }
98     }
99
100     public static INode getPossibleNearestParentOfType(INode node, Class<?> clazz) {
101         ParentNode<?> parent = null;
102         while (true) {
103             parent = node.getParent();
104             if (parent == null)
105                 return null;
106             node = parent;
107             if (clazz.isInstance(node))
108                 return node;
109         }
110     }
111
112     public static INode getRootNode(INode node) {
113         ParentNode<?> parent = null;
114         while (true) {
115             parent = node.getParent();
116             if (parent == null)
117                 return node;
118             node = parent;
119         }
120     }
121
122     public static G2DSceneGraph getRootNode(IG2DNode node) {
123         INode root = getRootNode((INode) node);
124         return (G2DSceneGraph) root;
125     }
126
127     public static G2DSceneGraph getPossibleRootNode(IG2DNode node) {
128         INode root = getRootNode((INode) node);
129         return (root instanceof G2DSceneGraph) ? (G2DSceneGraph) root : null;
130     }
131
132     /**
133      * Method for seeking node from scenegraph by class
134      * 
135      * @param <T>
136      * @param parent
137      * @param clazz
138      * @return
139      */
140     public static <T> T getNearestChildByClass(G2DParentNode parent, Class<T> clazz) {
141         return getNearestChildByClass(parent.getNodes(), clazz);
142     }
143
144     /**
145      * Breadth-first-search implementation to be used by getNearestChildByClass method
146      * 
147      * @param <T>
148      * @param nodes
149      * @param clazz
150      * @return
151      */
152     @SuppressWarnings("unchecked")
153     public static <T> T getNearestChildByClass(Collection<IG2DNode> nodes, Class<T> clazz) {
154         Collection<IG2DNode> list = null;
155         for (IG2DNode n : nodes) {
156             if (clazz.isInstance(n)) {
157                 return (T) n;
158             } else if (n instanceof G2DParentNode) {
159                 if (list == null)
160                     list = new ArrayList<IG2DNode>();
161                 list.addAll(((G2DParentNode)n).getNodes());
162             }
163         }
164         if (list == null || list.isEmpty()) return null;
165         return getNearestChildByClass(list, clazz);
166     }
167
168     /**
169      * Tries to look for a child node from the specified node with the specified
170      * ID. Returns <code>null</code> if the specified node is a not a
171      * {@link ParentNode}.
172      * 
173      * @param node
174      * @param id
175      * @return
176      */
177     public static INode getChildById(INode node, String id) {
178         if (node instanceof ParentNode<?>) {
179             return ((ParentNode<?>) node).getNode(id);
180         }
181         return null;
182     }
183
184     /**
185      * Looks for the first child node of the specified node based on 2D Z-order.
186      * The specified node must be a {@link G2DParentNode} for the method to
187      * succeed.
188      * 
189      * @param node the node to get for the first child from
190      * @return <code>null</code> if the specified node is not a
191      *         {@link G2DParentNode} or has no children.
192      */
193     public static INode getFirstChild(INode node) {
194         if (node instanceof G2DParentNode) {
195             G2DParentNode pn = (G2DParentNode) node;
196             IG2DNode[] sorted = pn.getSortedNodes();
197             if (sorted.length > 0)
198                 return sorted[0];
199         }
200         return null;
201     }
202
203     /**
204      * Returns a single child node of the specified node or <code>null</code> if
205      * there are more than one or zero children.
206      * 
207      * @param node the node to get a possible single child from
208      * @return single child node or <code>null</code> if specified node has more
209      *         than one or zero children
210      */
211     public static INode getPossibleChild(INode node) {
212         if (node instanceof ParentNode<?>) {
213             ParentNode<?> pn = (ParentNode<?>) node;
214             if (pn.getNodeCount() == 1)
215                 return pn.getNodes().iterator().next();
216         }
217         return null;
218     }
219
220     /**
221      * Counts the depth of the specified node in its scene graph node tree.
222      * Depth 1 equals root level.
223      * 
224      * @param node the node for which to count a depth
225      * @return the depth of the node
226      */
227     public static int getDepth(INode node) {
228         int result = 1;
229         ParentNode<?> parent = null;
230         while (true) {
231             parent = node.getParent();
232             if (parent == null)
233                 return result;
234             node = parent;
235             ++result;
236         }
237     }
238
239     private static final void printSceneGraph(PrintStream stream, int indentLevel, INode node, String id) {
240         for (int i = 0; i < indentLevel; ++i)
241             stream.print("\t");
242         stream.print(node.getSimpleClassName());
243         if (id != null) {               
244                 String lookupId = tryLookupId(node);
245                 if (lookupId != null) {
246                         stream.print(" {" + id + ", lookupId = "+lookupId+"}");
247                 } else {
248                         stream.print(" {" + id + "}");
249                 }
250         }
251         stream.println(node);
252         if (node instanceof G2DParentNode) {
253             G2DParentNode parentNode = (G2DParentNode) node;
254             for (String cid : parentNode.getSortedNodesById()) {
255                 Object child = parentNode.getNode(cid);
256                 if (child instanceof INode)
257                     printSceneGraph(stream, indentLevel + 1, (INode) child, cid);
258             }
259         } else if (node instanceof ParentNode<?>) {
260             ParentNode<? extends INode> parentNode = (ParentNode<?>) node;
261             for (String cid : parentNode.getNodeIds()) {
262                 INode child = parentNode.getNode(cid);
263                 printSceneGraph(stream, indentLevel + 1, (INode) child);
264             }
265         }
266     }
267
268     public static final void printSceneGraph(PrintStream stream, int indentLevel, INode node) {
269         String id = null;
270         ParentNode<?> parent = node.getParent();
271         if (parent != null) {
272             Collection<String> ids = parent.getNodeIds();
273             for (String i : ids) {
274                 INode n = parent.getNode(i);
275                 if (n == node) {
276                     id = i;
277                     break;
278                 }
279             }
280         }
281         printSceneGraph(stream, indentLevel, node, id);
282     }
283
284     public static final void printSceneGraph(int indentLevel, INode node) {
285         printSceneGraph(System.out, indentLevel, node);
286     }
287
288     public static final void printSceneGraph(INode node) {
289         printSceneGraph(System.out, 0, node);
290     }
291
292     @FunctionalInterface
293     public static interface NodeProcedure<T> {
294         T execute(INode node, String id);
295     }
296
297     /**
298      * @param node the node to iterate possible children for
299      * @param procedure invoked for each child node, if returns a
300      *        <code>non-null</code> value, the return value is collected into the result
301      *        list
302      * @return the list of collected children
303      */
304     public static final <T> List<T> forChildren(INode node, NodeProcedure<T> procedure) {
305         return forChildren(node, procedure, new ArrayList<T>());
306     }
307
308     /**
309      * @param node the node to iterate possible children for
310      * @param procedure invoked for each child node, if returns a
311      *        <code>non-null</code> value, the node is collected into the result
312      *        list
313      * @param result the result list into which selected children are collected
314      *        or <code>null</code> to not collect
315      * @return the list of collected children or null if provided result list
316      *         was <code>null</code>
317      */
318     public static final <T> List<T> forChildren(INode node, NodeProcedure<T> procedure, List<T> result) {
319         if (node instanceof ParentNode<?>) {
320             ParentNode<?> pn = (ParentNode<?>) node;
321             if (node instanceof G2DParentNode) {
322                 G2DParentNode g2dpn = (G2DParentNode) node;
323                 for (String id : g2dpn.getSortedNodesById()) {
324                     INode n = pn.getNode(id);
325                     T t = procedure.execute(n, id);
326                     if (t != null && result != null)
327                         result.add(t);
328                 }
329             } else {
330                 for (String id : pn.getNodeIds()) {
331                     INode n = pn.getNode(id);
332                     T t = procedure.execute(n, id);
333                     if (t != null && result != null)
334                         result.add(t);
335                 }
336             }
337         }
338         return result;
339     }
340
341     /**
342      * Recursively iterates through all child nodes of the specified node and
343      * for those nodes that are of class <code>ofClass</code>, invokes
344      * <code>consumer</code>.
345      * 
346      * @param node
347      * @param ofClass
348      * @param consumer
349      */
350     @SuppressWarnings("unchecked")
351     public static <T extends INode> INode forChildrenDeep(INode node, Class<T> ofClass, Function<T, INode> func) {
352         return forChildrenDeep(node, n -> ofClass.isInstance(n) ? func.apply((T) n) : null);
353     }
354
355     public static <T extends INode> INode forChildrenDeep(INode node, Function<INode, INode> func) {
356         INode ret = func.apply(node);
357         if (ret != null)
358             return ret;
359
360         if (node instanceof ParentNode<?>) {
361             if (node instanceof G2DParentNode) {
362                 G2DParentNode g2dpn = (G2DParentNode) node;
363                 for (IG2DNode n : g2dpn.getSortedNodes()) {
364                     INode r = forChildrenDeep(n, func);
365                     if (r != null) {
366                         return r;
367                     }
368                 }
369             } else {
370                 for (INode n : ((ParentNode<?>) node).getNodes()) {
371                     INode r = forChildrenDeep(n, func);
372                     if (r != null) {
373                         return r;
374                     }
375                 }
376             }
377         }
378
379         return null;
380     }
381
382     public static final int countTreeNodes(INode node) {
383         int result = 1;
384         if (node instanceof ParentNode<?>) {
385             ParentNode<? extends INode> pn = (ParentNode<?>) node;
386             Collection<? extends INode> ns = pn.getNodes();
387             for (INode n : ns) {
388                 result += countTreeNodes(n);
389             }
390         }
391         return result;
392     }
393
394     public static final StringBuilder printTreeNodes(INode node, StringBuilder builder) {
395         printTreeNodes(node, 0, builder);
396         return builder;
397     }
398
399     public static final StringBuilder printTreeNodes(INode node, int indent, StringBuilder builder) {
400         for (int i = 0; i < indent; i++)
401             builder.append(" ");
402         builder.append(node.toString() + "\n");
403         if (node instanceof ParentNode<?>) {
404             ParentNode<? extends INode> pn = (ParentNode<?>) node;
405             Collection<? extends INode> ns = pn.getNodes();
406             for (INode n : ns) {
407                 printTreeNodes(n, indent+2, builder);
408             }
409         }
410         return builder;
411     }
412
413     public static final <T extends INode> Set<T> collectNodes(INode node, Class<T> clazz) {
414         Set<T> result = new HashSet<T>();
415         collectNodes(node, clazz, result);
416         return result;
417     }
418
419     @SuppressWarnings("unchecked")
420     public static final <T extends INode> void collectNodes(INode node, Class<T> clazz, Set<T> result) {
421         if (clazz.isInstance(node))
422             result.add((T) node);
423         if (node instanceof ParentNode<?>) {
424             ParentNode<? extends INode> pn = (ParentNode<?>) node;
425             Collection<? extends INode> ns = pn.getNodes();
426             for (INode n : ns) {
427                 collectNodes(n, clazz, result);
428             }
429         }
430     }
431     
432     public static <T extends INode> T getSingleNode(INode node, Class<T> clazz) {
433         Set<T> all = collectNodes(node, clazz);
434         if(all.size() != 1) throw new RuntimeException("Expected exactly 1 instance of class " + clazz.getCanonicalName() + ", got " + all.size());
435         return (T)all.iterator().next();
436     }
437     
438     public static final boolean hasChildren(INode node) {
439         if (node instanceof ParentNode<?>) {
440             ParentNode<?> pn = (ParentNode<?>) node;
441             return !pn.getNodes().isEmpty();
442         }
443         return false;
444     }
445
446     /**
447      * Look for a single scene graph node by its ID in a path under a specified
448      * node.
449      * 
450      * @param parent the parent node under which to start looking
451      * @param idPath the node ID path
452      * @return <code>null</code> if node was not found
453      * @throws ClassCastException if the found node was not of the expected type
454      *         T extending INode
455      */
456     @SuppressWarnings("unchecked")
457     public static <T extends INode> T findNodeById(INode parent, String... idPath) {
458         INode n = parent;
459         for (int i = 0;; ++i) {
460             if (i >= idPath.length)
461                 return (T) n;
462             if (n instanceof ParentNode<?>) {
463                 n = ((ParentNode<?>) n).getNode(idPath[i]);
464             } else {
465                 return null;
466             }
467         }
468     }
469
470     /**
471      * Tries to find out whether a node is selected or not.
472      * 
473      * DISCLAIMER: this is a hack for the current
474      * org.simantics.g2d.diagram.participant.ElementPainter implementation that
475      * will stop working if the implementation changes.
476      * 
477      * @param node
478      * @param ascendLimit the max. amount of steps towards parent nodes to take
479      *        while looking for selection information
480      * @return <code>true</code> if evidence of selection is found
481      */
482     public static boolean isSelected(INode node, int ascendLimit) {
483         int steps = 0;
484         ParentNode<?> pn = null;
485         if (node instanceof ParentNode<?>) {
486             pn = (ParentNode<?>) node;
487         } else {
488             pn = node.getParent();
489             ++steps;
490         }
491         for (; pn != null && steps <= ascendLimit; pn = pn.getParent(), ++steps) {
492             INode child = pn.getNode(SELECTION_NODE_NAME);
493             if (child != null)
494                 return true;
495         }
496         return false;
497     }
498
499     public static Container findRootPane(INode node) {
500         G2DSceneGraph parent = findNearestParentNode(node, G2DSceneGraph.class);
501         if (parent == null)
502             return null;
503         return ((G2DSceneGraph) parent).getRootPane();
504     }
505
506     private static boolean isSelectionPainter(INode node) {
507         if (node instanceof ISelectionPainterNode) {
508             if (node instanceof IDynamicSelectionPainterNode)
509                 return ((IDynamicSelectionPainterNode)node).showsSelection();
510             return true;
511         }
512         return false;
513     }
514
515     /**
516      * @param elementNode
517      * @return
518      */
519     public static boolean needSelectionPaint(INode elementNode) {
520         // FIXME: there should be a cleaner way to implement this.
521
522         if (isSelectionPainter(elementNode)) {
523 //          System.out.println("skipped selection painting for connection node child ISelectionPainterNode");
524             return false;
525         }
526
527         if (elementNode instanceof ConnectionNode) {
528 //          System.out.println("connectionNode");
529             for (IG2DNode child : ((ConnectionNode) elementNode).getNodes()) {
530 //              System.out.println(" child " + child);
531                 if (isSelectionPainter(child)) {
532 //                  System.out.println("skipped selection painting for connection node child ISelectionPainterNode");
533                     return false;
534                 }
535                 if (child instanceof SingleElementNode) {
536                     for(IG2DNode child2 : ((SingleElementNode) child).getNodes()) {
537 //                      System.out.println(" child2 " + child2);
538                         if (isSelectionPainter(child2)) {
539 //                          System.out.println("skipped selection painting for edge ISelectionPainterNode");
540                             return false;
541                         }
542                     }
543                 }
544             }
545         } else if (elementNode instanceof SingleElementNode) {
546             for (INode child : ((SingleElementNode) elementNode).getNodes()) {
547                 if (isSelectionPainter(child))
548                     return false;
549             }
550         }
551
552         return true;
553     }
554
555     private static final String SET_THREAD_CALLBACKS_NAME = "CGLIB$SET_THREAD_CALLBACKS"; // If this method is found, the class is enhanced by cglib, thus does not contain annotations
556
557     public static Method getSetterForProperty(String property, INode node) {
558         assert(node != null);
559         Class<?> cl = node.getClass();
560
561         while(true) {
562             boolean isEnhanced = false;
563             for(Method method : cl.getMethods()) {
564                 if(method.isAnnotationPresent(PropertySetter.class)) {
565                     PropertySetter ann = method.getAnnotation(PropertySetter.class);
566                     if(ann.value().equals(property)) {
567                         return method;
568                     }
569                 } else if(method.getName().equals(SET_THREAD_CALLBACKS_NAME) && method.getGenericParameterTypes().length == 1) {
570                     // The class seems to be enhanced by cglib, hence annotations are not present. Check superclass for annotations..
571                     isEnhanced = true;
572                     cl = cl.getSuperclass();
573                     break; // We are not going to find any annotations, stop loop and try with the parent class
574                 }
575             }
576             if(!isEnhanced || cl == null) break;
577         }
578         return null;
579     }
580
581     /**
582      * TODO: log exceptions for debug purposes
583      * 
584      * @param property name of the property
585      * @param value    can be null..
586      * @param node
587      * @return
588      */
589     public static boolean setPropertyIfSupported(String property, Object value, INode node) {
590         Method setter = getSetterForProperty(property, node);
591         if(setter != null) {
592             Class<?> pc[] = setter.getParameterTypes();
593             if(pc.length == 1 && (value == null || pc[0].isAssignableFrom(value.getClass()))) {
594                 try {
595                     setter.invoke(node, value);
596                     return true;
597                 } catch (IllegalArgumentException e) {
598                     // TODO Auto-generated catch block
599                     e.printStackTrace();
600                 } catch (IllegalAccessException e) {
601                     // TODO Auto-generated catch block
602                     e.printStackTrace();
603                 } catch (InvocationTargetException e) {
604                     // TODO Auto-generated catch block
605                     e.getCause().printStackTrace();
606                 }
607             } else {
608
609                 if(pc.length > 0) {
610                     System.err.println("Method " + setter.getName() + " expects " + pc[0].getCanonicalName() + " (got " + value.getClass().getCanonicalName() + ").");
611                 }
612
613             }
614         }
615
616         return false;
617     }
618
619     public static INode findChildById(ParentNode<?> parent, String key) {
620         INode result = parent.getNode(key);
621         if (result != null)
622             return result;
623
624         for (String entry : parent.getNodeIds()) {
625             if (entry.startsWith(key))
626                 return parent.getNode(key);
627         }
628
629         for (INode node : parent.getNodes()) {
630             if (node instanceof ParentNode) {
631                 result = findChildById((ParentNode<?>) node, key);
632                 if (result != null)
633                     return result;
634             }
635         }
636
637         return null;
638     }
639
640     
641     private static int getSegmentEnd(String suffix) {
642         int pos;
643         for(pos=1;pos<suffix.length();++pos) {
644             char c = suffix.charAt(pos);
645             if(c == '/' || c == '#')
646                 break;
647         }
648         return pos;
649     }
650     
651     public static String decodeString(String string) {
652         return string;
653     }
654     
655     public static INode browsePossible(INode node, String suffix) {
656         if(suffix.isEmpty()) 
657             return node;        
658         switch(suffix.charAt(0)) {
659         case '.': {
660                 INode parent = node.getParent();
661             if(parent == null)
662                 return null;
663             return browsePossible(parent, suffix.substring(1));
664         }
665         case '#': {
666             /*int segmentEnd = getSegmentEnd(suffix);
667             Variable property = getPossibleProperty(graph, 
668                     decodeString(suffix.substring(1, segmentEnd)));
669             if(property == null) 
670                 return null;
671             return property.browsePossible(graph, suffix.substring(segmentEnd));*/
672                 return node;
673         }
674         case '/': {
675             int segmentEnd = getSegmentEnd(suffix);
676             INode child = findChildById((ParentNode<?>)node, decodeString(suffix.substring(1, segmentEnd)));
677             if(child == null) 
678                 return null;
679             return browsePossible(child, suffix.substring(segmentEnd));
680         }
681         default:
682             return null;
683         }
684     }    
685     
686     public static Pair<INode, String> browsePossibleReference(INode node, String suffix) {
687         if(suffix.isEmpty()) 
688             throw new RuntimeException("Did not find a reference.");        
689         switch(suffix.charAt(0)) {
690         case '.': {
691                 INode parent = node.getParent();
692             if(parent == null)
693                 return null;
694             return browsePossibleReference(parent, suffix.substring(1));
695         }
696         case '#': {
697                 return Pair.make(node, suffix.substring(1));
698         }
699         case '/': {
700             int segmentEnd = getSegmentEnd(suffix);
701             INode child = findChildById((ParentNode<?>)node, decodeString(suffix.substring(1, segmentEnd)));
702             if(child == null) 
703                 return null;
704             return browsePossibleReference(child, suffix.substring(segmentEnd));
705         }
706         default:
707             return null;
708         }
709     }    
710
711     public static INode findChildByPrefix(G2DParentNode parent, String prefix) {
712         INode result = parent.getNode(prefix);
713         if (result != null)
714             return result;
715
716         for (String entry : parent.getNodeIds()) {
717             if (entry.startsWith(prefix))
718                 return parent.getNode(entry);
719         }
720
721         for (IG2DNode node : parent.getNodes()) {
722             if (node instanceof G2DParentNode) {
723                 result = findChildByPrefix((G2DParentNode) node, prefix);
724                 if (result != null)
725                     return result;
726             }
727         }
728
729         return null;
730     }
731
732     /**
733      * @param parent
734      * @param prefix
735      * @return
736      */
737     public static Collection<String> filterDirectChildIds(ParentNode<?> parent, String prefix) {
738         return filterDirectChildIds(parent, new PrefixFilter(prefix));
739     }
740
741     /**
742      * @param parent
743      * @param prefix
744      * @return
745      */
746     public static Collection<String> filterDirectChildIds(ParentNode<?> parent, Filter<String> childFilter) {
747         Collection<String> childIds = parent.getNodeIds();
748         ArrayList<String> result = new ArrayList<String>(childIds.size());
749
750         for (String id : childIds)
751             if (childFilter.accept(id))
752                 result.add(id);
753
754         return result;
755     }
756
757     /**
758      * @param parent
759      * @param prefix
760      * @return
761      */
762     public static Collection<INode> filterDirectChildren(ParentNode<?> parent, Filter<String> childFilter) {
763         Collection<String> childIds = parent.getNodeIds();
764         ArrayList<INode> result = new ArrayList<INode>(childIds.size());
765
766         for (String id : childIds)
767             if (childFilter.accept(id))
768                 result.add( parent.getNode(id) );
769
770         return result;
771     }
772
773     /**
774      * @param node
775      * @return the lookup service for the specified node
776      * @throws UnsupportedOperationException if ILookupService is not available
777      */
778     public static ILookupService getLookupService(INode node) {
779         ParentNode<?> root = node.getRootNode();
780         if (!(root instanceof ILookupService))
781             throw new UnsupportedOperationException("ILookupService not supported by root node " + root + " attained from " + node);
782         return (ILookupService) root;
783     }
784
785     /**
786      * @param node
787      * @return <code>null</code> if lookup service is not available
788      */
789     public static ILookupService tryGetLookupService(INode node) {
790         ParentNode<?> root = node.getRootNode();
791         return root instanceof ILookupService ? (ILookupService) root : null;
792     }
793
794     /**
795      * @param node
796      * @param id
797      * @return <code>null</code> if lookup failed, i.e. mapping does not exist
798      * @throws UnsupportedOperationException if lookup is not supported
799      * @see #getLookupService(INode)
800      * @see ILookupService
801      */
802     public static INode lookup(INode node, String id) {
803         ILookupService lookup = getLookupService(node);
804         return lookup.lookupNode(id);
805     }
806
807     /**
808      * @param node
809      * @param id
810      * @return <code>null</code> if lookup not supported or lookup failed
811      * @see #tryGetLookupService(INode)
812      * @see ILookupService
813      */
814     public static INode tryLookup(INode node, String id) {
815         ILookupService lookup = tryGetLookupService(node);
816         return lookup != null ? lookup.lookupNode(id) : null;
817     }
818
819     /**
820      * @param node
821      * @param id
822      * @param clazz
823      * @return <code>null</code> if lookup failed, i.e. mapping does not exist
824      * @throws UnsupportedOperationException if lookup is not supported
825      * @throws ClassCastException if the found node cannot be cast to the
826      *         specified class
827      * @see #getLookupService(INode)
828      * @see ILookupService
829      */
830     public static <T> T lookup(INode node, String id, Class<T> clazz) {
831         ILookupService lookup = getLookupService(node);
832         INode found = lookup.lookupNode(id);
833         return found != null ? clazz.cast(found) : null;
834     }
835
836     /**
837      * @param node
838      * @param id
839      * @return <code>null</code> if lookup not supported or lookup failed
840      * @see #tryGetLookupService(INode)
841      * @see ILookupService
842      */
843     public static <T> T tryLookup(INode node, String id, Class<T> clazz) {
844         ILookupService lookup = tryGetLookupService(node);
845         if (lookup == null)
846             return null;
847         INode found = lookup.lookupNode(id);
848         return found != null ? clazz.cast(found) : null;
849     }
850
851     /**
852      * @param node
853      * @param id
854      * @return <code>null</code> if lookup failed, i.e. mapping does not exist
855      * @throws UnsupportedOperationException if lookup is not supported
856      * @see #getLookupService(INode)
857      * @see ILookupService
858      */
859     public static String lookupId(INode node) {
860         ILookupService lookup = getLookupService(node);
861         return lookup.lookupId(node);
862     }
863
864     /**
865      * @param node
866      * @param id
867      * @return <code>null</code> if lookup not supported or lookup failed
868      * @see #tryGetLookupService(INode)
869      * @see ILookupService
870      */
871     public static String tryLookupId(INode node) {
872         ILookupService lookup = tryGetLookupService(node);
873         return lookup != null ? lookup.lookupId(node) : null;
874     }
875
876     /**
877      * Map the specified node to the specified ID in the {@link ILookupService}
878      * provided by the root node of the specified node.
879      * 
880      * @param node
881      * @param id
882      * @throws UnsupportedOperationException if {@link ILookupService} is not
883      *         available for the specified node
884      * @see #getLookupService(INode)
885      * @see ILookupService
886      */
887     public static void map(INode node, String id) {
888         getLookupService(node).map(id, node);
889     }
890
891     /**
892      * Remove possible ILookupService mapping for the specified node.
893      * 
894      * @param node the node to try to remove mappings for
895      * @return mapped ID or <code>null</code> if no mapping existed
896      * @throws UnsupportedOperationException if {@link ILookupService} is not
897      *         available for the specified node
898      * @see ILookupService
899      * @see #getLookupService(INode)
900      */
901     public static String unmap(INode node) {
902         return getLookupService(node).unmap(node);
903     }
904
905     /**
906      * Try to remove possible ILookupService mapping for the specified node.
907      * 
908      * @param node the node to try to remove mappings for
909      * @return mapped ID or <code>null</code> if {@link ILookupService} is not
910      *         supported or no mapping existed
911      * @see ILookupService
912      * @see #tryGetLookupService(INode)
913      */
914     public static String tryUnmap(INode node) {
915         ILookupService lookup = tryGetLookupService(node);
916         return lookup != null ? lookup.unmap(node) : null;
917     }
918
919     public static EventDelegator getEventDelegator(INode node) {
920         ParentNode<?> n = node.getRootNode();
921         if (n instanceof G2DSceneGraph) {
922             return ((G2DSceneGraph) n).getEventDelegator();
923         }
924         return null;
925     }
926
927     public static NodeEventHandler getNodeEventHandler(INode node) {
928         ParentNode<?> n = node.getRootNode();
929         return (n instanceof G2DSceneGraph) ? ((G2DSceneGraph) n).getEventHandler() : null;
930 //        INodeEventHandlerProvider provider = findNearestParentNode(node, INodeEventHandlerProvider.class);
931 //        return provider != null ? provider.getEventHandler() : null;
932     }
933
934     public static AWTEvent transformEvent(AWTEvent event, IG2DNode node) {
935         if (event instanceof MouseEvent) {
936             // Find node transform..
937             AffineTransform transform = getGlobalToLocalTransform(node, null);
938             if (transform == null) {
939                 System.err.println("WARNING: Non-invertible transform for node: " + node);
940                 return event;
941             }
942             MouseEvent me = (MouseEvent)event;
943             // Use double coordinates if available
944             Point2D p = new Point2D.Double((double)me.getX(), (double)me.getY());
945             transform.transform(p, p);
946
947             MouseEvent e = null;
948             // Giving event.getSource() as a parameter for the new events will cause major delay for the event instantiation, hence dummy component is used
949             if (event instanceof MouseWheelEvent) {
950                 e = new SGMouseWheelEvent(new DummyComponent(), me.getID(), me.getWhen(), me.getModifiers(), p.getX(), p.getY(), me.getClickCount(), me.isPopupTrigger(), ((MouseWheelEvent)me).getScrollType(), ((MouseWheelEvent)me).getScrollAmount(), ((MouseWheelEvent)me).getWheelRotation(), me);
951             } else {
952                 e = new SGMouseEvent(new DummyComponent(), me.getID(), me.getWhen(), me.getModifiers(), p.getX(), p.getY(), me.getClickCount(), me.isPopupTrigger(), me.getButton(), me);
953             }
954             return e;
955         }
956         return event;
957     }
958
959     private static final boolean DEBUG_BOUNDS = false;
960
961     private static Rectangle2D getLocalBoundsImpl(INode node, Function1<INode, Boolean> filter, int indent) {
962         if (node instanceof IG2DNode) {
963             if (node instanceof G2DParentNode) {
964                 G2DParentNode pNode = (G2DParentNode)node;
965                 Iterator<IG2DNode> it = pNode.getNodes().iterator();
966                 if (!it.hasNext())
967                     return null;
968                 Rectangle2D bounds = null;
969                 while (it.hasNext()) {
970                     IG2DNode next = it.next();
971                     if (filter != null && !filter.apply(next))
972                         continue;
973
974                     Rectangle2D bl = getLocalBoundsImpl(next, filter, indent+2);
975
976                     if(DEBUG_BOUNDS) {
977                         for(int i=0;i<indent;i++) System.err.print(" ");
978                         System.err.println("+getLocalBoundsImpl " + next  + " => " + bl);
979                     }
980
981                     if(bl != null) {
982                         if(bounds == null) {
983                             bounds = next.localToParent(bl.getFrame());
984                         } else {
985                             bounds.add(next.localToParent(bl));
986                         }
987                     }
988                 }
989
990                 if(DEBUG_BOUNDS) {
991                     for(int i=0;i<indent;i++) System.err.print(" ");
992                     System.err.println("=getLocalBoundsImpl " + node  + " => " + bounds);
993                 }
994
995                 return bounds;
996             } else {
997                 Rectangle2D result = ((IG2DNode)node).getBoundsInLocal(true);
998                 if(result != null) {
999                     if(DEBUG_BOUNDS) {
1000                         for(int i=0;i<indent;i++) System.err.print(" ");
1001                         System.err.println("=getLocalBoundsImpl " + node  + " => " + result);
1002                     }
1003                     return result;
1004                 }
1005             }
1006         }
1007         return null;
1008     }
1009
1010     public static Rectangle2D getLocalBounds(INode node) {
1011         return getLocalBoundsImpl(node, null, 0);
1012     }
1013
1014     public static Rectangle2D getLocalBounds(INode node, final Set<INode> excluding) {
1015         return getLocalBoundsImpl(node, new FunctionImpl1<INode, Boolean>() {
1016
1017                         @Override
1018                         public Boolean apply(INode node) {
1019                                 return !excluding.contains(node);
1020                         }
1021         }, 0);
1022     }
1023
1024     public static Rectangle2D getLocalBounds(INode node, final Class<?> excluding) {
1025         return getLocalBoundsImpl(node, new FunctionImpl1<INode, Boolean>() {
1026
1027                         @Override
1028                         public Boolean apply(INode node) {
1029                                 return !excluding.isInstance(node);
1030                         }
1031         }, 0);
1032     }
1033
1034     public static Rectangle2D getLocalElementBounds(INode node) {
1035         if(node instanceof ConnectionNode) {
1036             return getLocalBounds(node);
1037         } else if(node instanceof SingleElementNode) {
1038             // For normal symbols
1039             INode image = NodeUtil.findChildByPrefix((SingleElementNode)node, "composite_image");
1040             if (image == null)
1041                 // For generic text nodes
1042                 image = NodeUtil.findChildByPrefix((SingleElementNode) node, "text");
1043             if (image == null)
1044                 // For I/O table diagram flags (value of org.simantics.diagram.flag.FlagSceneGraph.VISUAL_ROOT)
1045                 image = NodeUtil.findChildByPrefix((SingleElementNode) node, "visual");
1046             if (image == null)
1047                 image = NodeUtil.getNearestChildByClass((SingleElementNode) node, FlagNode.class);
1048             if (image != null)
1049                 return getLocalElementBounds(image);
1050             else
1051                 return getLocalBounds(node);
1052         } else {
1053             return getLocalBounds(node);
1054         }
1055     }
1056
1057     public static <T> T findNearestParentNode(INode node, Class<T> ofClass) {
1058         ParentNode<?> parent = null;
1059         while (true) {
1060             parent = node.getParent();
1061             if (parent == null)
1062                 return null;
1063             if (ofClass.isInstance(parent))
1064                 return ofClass.cast(parent);
1065             node = parent;
1066         }
1067     }
1068  
1069     private static class PendingTester implements Runnable {
1070
1071         private boolean             pending     = true;
1072         private final G2DSceneGraph sg;
1073
1074         private final Lock          pendingLock = new ReentrantLock();
1075         private final Condition     pendingSet  = pendingLock.newCondition();
1076
1077         public PendingTester(G2DSceneGraph sg) {
1078             this.sg = sg;
1079         }
1080
1081         @Override
1082         public void run() {
1083             pendingLock.lock();
1084             try {
1085                 pending = sg.isPending();
1086                 pendingSet.signalAll();
1087             } finally {
1088                 pendingLock.unlock();
1089             }
1090         }
1091
1092         public boolean isPending() {
1093             return pending;
1094         }
1095
1096         public void await() {
1097             pendingLock.lock();
1098             try {
1099                 if (pending)
1100                     pendingSet.await(10, TimeUnit.MILLISECONDS);
1101             } catch (InterruptedException e) {
1102                 // Ignore.
1103             } finally {
1104                 pendingLock.unlock();
1105             }
1106         }
1107
1108     }
1109
1110     public static void waitPending(IThreadWorkQueue thread, G2DSceneGraph sg) {
1111         // Wait for 30s by default
1112         waitPending(thread, sg, 30000);
1113     }
1114
1115     /**
1116      * Synchronously waits until the the specified scene graph is no longer in
1117      * pending state.
1118      * 
1119      * @param thread the thread to schedule pending checks into
1120      * @param sg the scene graph to wait upon
1121      */
1122     public static void waitPending(IThreadWorkQueue thread, G2DSceneGraph sg, int timeoutMs) {
1123         PendingTester tester = new PendingTester(sg);
1124         long start = System.currentTimeMillis();
1125         while (tester.isPending()) {
1126             thread.asyncExec(tester);
1127             if (tester.isPending())
1128                 tester.await();
1129             long duration = System.currentTimeMillis() - start;
1130             if(duration > timeoutMs)
1131                 throw new IllegalStateException("Timeout in resolving pending nodes.");
1132         }
1133     }
1134
1135     public static void increasePending(INode node) {
1136         G2DSceneGraph sg = (G2DSceneGraph) node.getRootNode();
1137         if(sg != null)
1138                 sg.increasePending(node);
1139     }
1140
1141     public static void decreasePending(INode node) {
1142         G2DSceneGraph sg = (G2DSceneGraph) node.getRootNode();
1143         if(sg != null)
1144                 sg.decreasePending(node);
1145     }
1146
1147     // TRANSFORMATIONS
1148
1149     public static AffineTransform getLocalToGlobalTransform(IG2DNode node, AffineTransform result) {
1150         result.setToIdentity();
1151         ParentNode<?> parent = node.getParent();
1152         while (parent != null) {
1153             result.preConcatenate(((IG2DNode) parent).getTransform());
1154             parent = parent.getParent();
1155         }
1156         return result;
1157     }
1158
1159     public static AffineTransform getLocalToGlobalTransform(IG2DNode node) {
1160         return getLocalToGlobalTransform(node, new AffineTransform());
1161     }
1162
1163     public static AffineTransform getGlobalToLocalTransform(IG2DNode node) throws NoninvertibleTransformException {
1164         AffineTransform transform = getLocalToGlobalTransform(node);
1165         transform.invert();
1166         return transform;
1167     }
1168
1169     public static AffineTransform getGlobalToLocalTransform(IG2DNode node, AffineTransform returnIfNonInvertible) {
1170         AffineTransform transform = getLocalToGlobalTransform(node);
1171         try {
1172             transform.invert();
1173             return transform;
1174         } catch (NoninvertibleTransformException e) {
1175             return returnIfNonInvertible;
1176         }
1177     }
1178
1179     public static Point2D worldToLocal(IG2DNode local, Point2D pt, Point2D pt2) {
1180         AffineTransform at = getGlobalToLocalTransform(local, null);
1181         if (at == null) {
1182                 pt2.setLocation(pt);
1183             return pt2;
1184         }
1185         return at.transform(pt, pt2);
1186     }
1187
1188     public static Point2D localToWorld(IG2DNode local, Point2D pt, Point2D pt2) {
1189         AffineTransform at = getLocalToGlobalTransform(local);
1190         return at.transform(pt, pt2);
1191     }
1192
1193     public static String getNodeName(INode nn) {
1194         INode node = nn.getParent();
1195         ParentNode<?> pn = (ParentNode<?>) node;
1196         if (node instanceof G2DParentNode) {
1197             G2DParentNode g2dpn = (G2DParentNode) node;
1198             for (String id : g2dpn.getSortedNodesById()) 
1199             {
1200                 INode n = pn.getNode(id);
1201                 if ( nn == n ) {
1202                         return id;
1203                 }
1204             }
1205         }
1206         return null;
1207     }
1208
1209     /**
1210      * For asking whether specified parent node really is a parent of the
1211      * specified child node.
1212      * 
1213      * @param parent
1214      *            the parent
1215      * @param child
1216      *            alleged child of parent
1217      * @return <code>true</code> if parent really is a parent of child
1218      */
1219     public static boolean isParentOf(INode parent, INode child) {
1220         while (true) {
1221             if (parent == child)
1222                 return true;
1223             child = child.getParent();
1224             if (child == null)
1225                 return false;
1226         }
1227     }
1228
1229 }