bundles/org.simantics.scenegraph/src/org/simantics/scenegraph/g2d/G2DSceneGraph.java

   1 /*******************************************************************************\r
   2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management\r
   3  * in Industry THTH ry.\r
   4  * All rights reserved. This program and the accompanying materials\r
   5  * are made available under the terms of the Eclipse Public License v1.0\r
   6  * which accompanies this distribution, and is available at\r
   7  * http://www.eclipse.org/legal/epl-v10.html\r
   8  *\r
   9  * Contributors:\r
  10  *     VTT Technical Research Centre of Finland - initial API and implementation\r
  11  *******************************************************************************/\r
  12 package org.simantics.scenegraph.g2d;
  13
  14 import java.awt.Component;\r
  15 import java.awt.Container;\r
  16 import java.awt.Graphics2D;\r
  17 import java.util.ArrayDeque;\r
  18 import java.util.Deque;\r
  19 import java.util.HashMap;\r
  20 import java.util.HashSet;\r
  21 import java.util.Map;\r
  22 import java.util.Set;\r
  23 import java.util.logging.Level;\r
  24 import java.util.logging.Logger;\r
  25 \r
  26 import javax.swing.JComponent;\r
  27 import javax.swing.RepaintManager;\r
  28 \r
  29 import org.simantics.scenegraph.ILookupService;\r
  30 import org.simantics.scenegraph.INode;\r
  31 import org.simantics.scenegraph.LookupService;\r
  32 import org.simantics.scenegraph.ParentNode;\r
  33 import org.simantics.scenegraph.g2d.events.EventDelegator;\r
  34 import org.simantics.scenegraph.g2d.events.INodeEventHandlerProvider;\r
  35 import org.simantics.scenegraph.g2d.events.NodeEventHandler;\r
  36 \r
  37 /**\r
  38  * The root node of a 2D scene graph.\r
  39  * \r
  40  * Implements {@link ILookupService} according to the reference implementation\r
  41  * {@link LookupService}.\r
  42  * \r
  43  * @author J-P Laine\r
  44  */\r
  45 @SuppressWarnings("deprecation")\r
  46 public class G2DSceneGraph extends G2DParentNode implements ILookupService, INodeEventHandlerProvider {\r
  47 \r
  48     private static final long          serialVersionUID = -7066146333849901429L;\r
  49     \r
  50     public static final String        IGNORE_FOCUS = "ignoreFocus";\r
  51 \r
  52     protected transient Container     rootPane         = null;\r
  53     // TODO: swing dependency in here might not be a good idea\r
  54
  55     // This variable is actually used in remote use, when rendering is not performed locally\r
  56     private transient final Object     treeLock         = new Object();\r
  57 \r
  58     private HashMap<Object, Integer>   pending          = new HashMap<Object, Integer>();\r
  59     private HashMap<String, Object>    globalProperties = new HashMap<String, Object>();\r
  60 \r
  61     /**\r
  62      * For preventing duplicates on the nodesToRemove queue.\r
  63      */\r
  64     protected transient Set<INode>     nodesToRemoveSet = new HashSet<INode>();\r
  65     protected Deque<INode>             nodesToRemove    = new ArrayDeque<INode>();\r
  66 \r
  67     private transient EventDelegator   eventDelegator   = new EventDelegator(this);\r
  68     private transient NodeEventHandler eventHandler     = new NodeEventHandler(this);\r
  69 \r
  70     /**\r
  71      * The node that has input focus in the scene graph. The input node will\r
  72      * receive key and command events.\r
  73      */\r
  74     private transient IG2DNode         focusNode;\r
  75 \r
  76     /**\r
  77      * The custom repaint manager of this scene graph.\r
  78      */\r
  79     private transient G2DRepaintManager repaintManager;\r
  80 \r
  81     /**\r
  82      * Returns the event delegator, that is responsible for delegating events to nodes in the sg tree\r
  83      * \r
  84      * @return EventDelegator instance, always not null\r
  85      */\r
  86     public EventDelegator getEventDelegator() {\r
  87         return eventDelegator;\r
  88     }\r
  89 \r
  90     /**\r
  91      * Returns the node event handler, that is responsible for delegating events\r
  92      * to nodes in the sg tree.\r
  93      * \r
  94      * @return NodeEventHandler instance for this scene graph, always non-null\r
  95      */\r
  96     public NodeEventHandler getEventHandler() {\r
  97         return eventHandler;\r
  98     }\r
  99 \r
 100     public void setFocusNode(IG2DNode focusNode) {\r
 101         this.focusNode = focusNode;\r
 102     }\r
 103 \r
 104     public IG2DNode getFocusNode() {\r
 105         return focusNode;\r
 106     }\r
 107
 108     @Override
 109     public void render(Graphics2D g2d) {
 110         performCleanup();\r
 111         Component rootPane = getRootPane();\r
 112         if (rootPane != null)\r
 113             g2d.setRenderingHint(G2DRenderingHints.KEY_COMPONENT, rootPane);\r
 114         synchronized(treeLock) {
 115             super.render(g2d);
 116         }
 117     }\r
 118 \r
 119     /**\r
 120      * Util method for executing updates to scenegraph tree\r
 121      * NOTE: You should really consider performance issues when using this\r
 122      * \r
 123      * @param r  Runnable to be executed while rendering is not performed\r
 124      */\r
 125     public void syncExec(Runnable r) {\r
 126         synchronized(treeLock) {\r
 127             r.run();\r
 128         }\r
 129     }
 130 \r
 131     /**\r
 132      * Set rootpane for swing components. This is used as parent for the components created by ComponentNode.\r
 133      * \r
 134      * @param rootPane Component that is used as a parent for the swing component (This shouldn't be visible)\r
 135      */
 136     public void setRootPane(JComponent rootPane) {
 137         synchronized (RepaintManager.class) {\r
 138             RepaintManager old = RepaintManager.currentManager(rootPane);
 139             old = findProperRepaintManager(old);\r
 140             this.repaintManager = new G2DRepaintManager(rootPane.getClass(), old);\r
 141             RepaintManager.setCurrentManager(repaintManager);\r
 142         }\r
 143         this.rootPane = rootPane;
 144     }\r
 145 \r
 146     /**\r
 147      * Set rootpane for swing components. This is used as parent for the components created by ComponentNode.\r
 148      * Supports separate component that is responsible for repainting the scenegraph.\r
 149      * \r
 150      * @param rootPane     Component that is used as a parent for the swing component (This shouldn't be visible)\r
 151      * @param paintContext Component that is responsible for repainting the scenegraph\r
 152      */
 153     public void setRootPane(Container rootPane, Component paintContext) {\r
 154         synchronized (RepaintManager.class) {\r
 155             RepaintManager old = RepaintManager.currentManager(paintContext);\r
 156             old = findProperRepaintManager(old);\r
 157             this.repaintManager = new G2DRepaintManager(paintContext.getClass(), old);\r
 158             RepaintManager.setCurrentManager(repaintManager);\r
 159         }\r
 160         this.rootPane = rootPane;\r
 161         eventHandler.setRootPane(rootPane);\r
 162     }\r
 163
 164     private RepaintManager findProperRepaintManager(RepaintManager old) {\r
 165         while (old instanceof G2DRepaintManager) {\r
 166             G2DRepaintManager g2drm = (G2DRepaintManager) old;\r
 167             old = g2drm.getDelegate();\r
 168         }\r
 169         return old;\r
 170     }\r
 171 \r
 172     public G2DRepaintManager getRepaintManager() {\r
 173         return repaintManager;\r
 174     }\r
 175 \r
 176     /**
 177      * Put the node to the remove queue
 178      */
 179     @Override
 180     public void asyncRemoveNode(INode node) {
 181         synchronized(nodesToRemove) {\r
 182             // Prevent nodes from winding up twice on the nodesToRemove queue\r
 183             if (nodesToRemoveSet.add(node)) {
 184                 nodesToRemove.add(node); // This is performed when called inside the render\r
 185             }
 186         }
 187     }
 188
 189     /**
 190      * Perform the actual removal of the nodes in the nodesToRemove list
 191      */
 192     public void performCleanup() {
 193         synchronized(nodesToRemove) {
 194             while(nodesToRemove.size() > 0) {
 195                 INode node = nodesToRemove.removeFirst();
 196                 ParentNode<?> parent = node.getParent();\r
 197                 // This works around issue #2071\r
 198                 if (parent != null)
 199                     parent.removeNode(node);
 200             }\r
 201             if (!nodesToRemoveSet.isEmpty())\r
 202                 nodesToRemoveSet.clear();\r
 203         }
 204     }
 205 \r
 206     @Override\r
 207     public void cleanup() {\r
 208         super.cleanup();\r
 209         nodesToRemove.clear();\r
 210         nodesToRemove = null;\r
 211         nodesToRemoveSet.clear();\r
 212         nodesToRemoveSet = null;\r
 213         eventHandler.dispose();\r
 214         eventHandler = null;\r
 215         eventDelegator.dispose();\r
 216         eventDelegator = null;\r
 217     }\r
 218
 219     public Container getRootPane() {
 220         return (Container) this.rootPane;
 221     }\r
 222 \r
 223     @Override
 224     public String toString() {
 225         return super.toString() + " [root pane=" + rootPane + "]";
 226     }
 227
 228     @Override\r
 229     public ParentNode<?> getRootNode() {\r
 230         // This is a root node!\r
 231         return this;\r
 232     }\r
 233 \r
 234     // ILookupService implementation\r
 235 \r
 236     private final Object             lookupLock = new Object();\r
 237     private final Map<String, INode> toNode     = new HashMap<String, INode>();\r
 238     private final Map<INode, String> toId       = new HashMap<INode, String>();\r
 239 \r
 240     transient Logger                 logger     = Logger.getLogger(getClass().getName());\r
 241 \r
 242     @Override\r
 243     public INode map(String id, INode node) {\r
 244         if (id == null)\r
 245             throw new NullPointerException("null id");\r
 246         if (node == null)\r
 247             throw new NullPointerException("null node");\r
 248 \r
 249         INode oldNode;\r
 250         String oldId;\r
 251         synchronized (lookupLock) {\r
 252             oldNode = toNode.put(id, node);\r
 253             oldId = toId.put(node, id);\r
 254 \r
 255             // Keep the mapping a consistent bijection:\r
 256             // If ID => INode mapping is removed, the INode => ID mappings must\r
 257             // removed also.\r
 258 \r
 259             if (oldNode != null && !oldNode.equals(node)) {\r
 260                 String removedId = toId.remove(oldNode);\r
 261                 if (!id.equals(removedId))\r
 262                     toNode.remove(removedId);\r
 263             }\r
 264             if (oldId != null && !oldId.equals(id)) {\r
 265                 INode removedNode = toNode.remove(oldId);\r
 266                 if (removedNode != node)\r
 267                     toId.remove(removedNode);\r
 268             }\r
 269         }\r
 270         if (logger.isLoggable(Level.FINER))\r
 271             logger.fine("map(" + id + ", " + node + ")");\r
 272         if (oldNode != null || oldId != null) {\r
 273             if (logger.isLoggable(Level.FINE)) {\r
 274                 logger.info("replaced mappings for ID " + oldId + " and node " + oldNode);\r
 275             }\r
 276         }\r
 277         return oldNode;\r
 278     }\r
 279 \r
 280     @Override\r
 281     public INode unmap(String id) {\r
 282         INode node;\r
 283         String mappedId;\r
 284         synchronized (lookupLock) {\r
 285             node = toNode.remove(id);\r
 286             if (node == null)\r
 287                 return null;\r
 288             mappedId = toId.remove(node);\r
 289         }\r
 290         if (logger.isLoggable(Level.FINER))\r
 291             logger.fine("unmap(" + id + "): " + node);\r
 292         if (mappedId != null && !mappedId.equals(id)) {\r
 293             if (logger.isLoggable(Level.WARNING))\r
 294                 logger.log(Level.WARNING, "mapping was out-of-sync: " + id + " => " + node + " & " + mappedId + " => " + node, new Exception("trace"));\r
 295         }\r
 296         return node;\r
 297     }\r
 298 \r
 299     @Override\r
 300     public String unmap(INode node) {\r
 301         String id;\r
 302         INode mappedNode;\r
 303         synchronized (lookupLock) {\r
 304             id = toId.remove(node);\r
 305             if (node == null)\r
 306                 return null;\r
 307             mappedNode = toNode.remove(id);\r
 308         }\r
 309         if (logger.isLoggable(Level.FINER))\r
 310             logger.fine("unmap(" + node + "): " + id);\r
 311         if (mappedNode != null && node != mappedNode) {\r
 312             if (logger.isLoggable(Level.WARNING))\r
 313                 logger.log(Level.WARNING, "mapping was out-of-sync: " + node + " => " + id + " & " + id + " => " + mappedNode, new Exception("trace"));\r
 314         }\r
 315         return id;\r
 316     }\r
 317 \r
 318     @Override\r
 319     public INode lookupNode(String id) {\r
 320         synchronized (lookupLock) {\r
 321             return toNode.get(id);\r
 322         }\r
 323     }\r
 324 \r
 325     @Override\r
 326     public String lookupId(INode node) {\r
 327         synchronized (lookupLock) {\r
 328             return toId.get(node);\r
 329         }\r
 330     }\r
 331 \r
 332     public boolean isPending() {\r
 333         return !pending.isEmpty();\r
 334     }\r
 335 \r
 336     synchronized public void increasePending(Object object) {\r
 337         Integer ref = pending.get(object);\r
 338         if (ref == null) pending.put(object, 1);\r
 339         else pending.put(object, ref+1);\r
 340     }\r
 341 \r
 342     synchronized public void setPending(Object object) {\r
 343         pending.put(object, 1);\r
 344     }\r
 345 \r
 346     synchronized public void clearPending(Object object) {\r
 347         pending.remove(object);\r
 348     }\r
 349 \r
 350     synchronized public void decreasePending(Object object) {\r
 351         Integer ref = pending.get(object);\r
 352         if (ref == null) {\r
 353             return;\r
 354             //throw new IllegalStateException("Ref count in unregister was 0 for " + object);\r
 355         }\r
 356         if (ref > 1) pending.put(object, ref-1);\r
 357         else if (ref==1) pending.remove(object);\r
 358         else {\r
 359             return;\r
 360             //throw new IllegalStateException("Ref count in unregister was 0 for " + object);\r
 361         }\r
 362     }\r
 363     \r
 364     synchronized public void setGlobalProperty(String key, Object value) {\r
 365         globalProperties.put(key, value);\r
 366     }\r
 367     \r
 368     @SuppressWarnings("unchecked")\r
 369         synchronized public <T> T getGlobalProperty(String key, T defaultValue) {\r
 370         T t = (T)globalProperties.get(key);\r
 371         if(t == null) return defaultValue;\r
 372         return t;\r
 373     }\r
 374 \r
 375 }