]> gerrit.simantics Code Review - simantics/3d.git/commitdiff
Preventing synchronizing commits after undo / redo are mandatory 17/3117/2
authorMarko Luukkainen <marko.luukkainen@semantum.fi>
Mon, 19 Aug 2019 12:52:48 +0000 (15:52 +0300)
committerMarko Luukkainen <marko.luukkainen@semantum.fi>
Mon, 19 Aug 2019 14:41:33 +0000 (17:41 +0300)
Allowing synchronizing commits with empty message and no undo point
trash the undo history and prevent redo operations.

Include scl folder in build.properties

gitlab #24

Change-Id: I0af0cbf3be21a23ac4f8ed20a48881bef21465d2

org.simantics.g3d.vtk/src/org/simantics/g3d/vtk/common/AbstractVTKNodeMap.java
org.simantics.g3d/build.properties
org.simantics.plant3d/build.properties

index 6194ec822a0d8ef51fa7a202be5bbd0e1eff3f62..b5a7dfe60b8a316d93aa7f7e9cd09f77a6a5aba7 100644 (file)
@@ -23,6 +23,7 @@ import java.util.Stack;
 
 import org.simantics.db.ReadGraph;
 import org.simantics.db.Session;
+import org.simantics.db.UndoContext;
 import org.simantics.db.WriteGraph;
 import org.simantics.db.common.request.ReadRequest;
 import org.simantics.db.common.request.WriteRequest;
@@ -47,261 +48,273 @@ import vtk.vtkProp;
 
 public abstract class AbstractVTKNodeMap<E extends INode> implements VTKNodeMap<E>, IMappingListener, RenderListener, NodeListener, UndoRedoSupport.ChangeListener{
 
-       private static final boolean DEBUG = false;
-       
-       protected Session session;
-       protected IMapping<Object,E> mapping;
-       protected VtkView view;
-       
-       protected MapList<E, vtkProp> nodeToActor = new MapList<E, vtkProp>();
-       protected Map<vtkProp,E> actorToNode = new HashMap<vtkProp, E>();
+    private static final boolean DEBUG = false;
+    
+    protected Session session;
+    protected IMapping<Object,E> mapping;
+    protected VtkView view;
+    
+    protected MapList<E, vtkProp> nodeToActor = new MapList<E, vtkProp>();
+    protected Map<vtkProp,E> actorToNode = new HashMap<vtkProp, E>();
 
-       protected ParentNode<E> rootNode;
-       
-       protected UndoRedoSupport undoRedoSupport;
-       protected int undoOpCount = 0;
-       protected boolean runUndo = false;
-       public AbstractVTKNodeMap(Session session, IMapping<Object,E> mapping, VtkView view, ParentNode<E> rootNode) {
-               this.session = session;
-               this.mapping = mapping;
-               this.view = view;
-               this.rootNode = rootNode;
-               view.addListener(this);
-               mapping.addMappingListener(this);
-               rootNode.addListener(this);
-               
-               undoRedoSupport = session.getService(UndoRedoSupport.class);
-               undoRedoSupport.subscribe(this);
-               try {
-                   undoOpCount = undoRedoSupport.getUndoContext(session).getAll().size();
-               } catch(DatabaseException e) {
-                   e.printStackTrace();
-               }
-       }
-       
-       
-       
-       protected abstract void addActor(E node);
-       protected abstract void removeActor(E node);
-       protected abstract void updateActor(E node,Set<String> ids);
-       
-       public void repaint() {
-               view.refresh();
-       }
-       
-       public void populate() {
-               for (E node : rootNode.getNodes()) {
-                       receiveAdd(node, node.getParentRel(),true);
-               }
-               repaint();
-       }
-       
-       @Override
-       public E getNode(vtkProp prop) {
-               return actorToNode.get(prop);
-       }
-       
-       @SuppressWarnings("unchecked")
-       @Override
-       public Collection<vtkProp> getRenderObjects(INode node) {
-               return nodeToActor.getValues((E)node);
-       }
-       
-       @SuppressWarnings("unchecked")
-       @Override
-       public ParentNode<E> getRootNode() {
-               return (ParentNode<E>)rootNode;
-       }
-       
-       
-       
-       @Override
-       public boolean isChangeTracking() {
-               return changeTracking;
-       }
-       
-       @Override
-       public void setChangeTracking(boolean enabled) {
-               changeTracking = enabled;
-       }
-       
-       private boolean changeTracking = true;
-       
-       protected Object syncMutex = new Object(); 
-       
+    protected ParentNode<E> rootNode;
+    
+    protected UndoRedoSupport undoRedoSupport;
+    protected int undoOpCount = 0;
+    protected int redoOpCount = 0;
+    protected boolean runUndo = false;
+    protected boolean runRedo = false;
+    public AbstractVTKNodeMap(Session session, IMapping<Object,E> mapping, VtkView view, ParentNode<E> rootNode) {
+        this.session = session;
+        this.mapping = mapping;
+        this.view = view;
+        this.rootNode = rootNode;
+        view.addListener(this);
+        mapping.addMappingListener(this);
+        rootNode.addListener(this);
+        
+        undoRedoSupport = session.getService(UndoRedoSupport.class);
+        undoRedoSupport.subscribe(this);
+        try {
+            UndoContext undoContext = undoRedoSupport.getUndoContext(session); 
+            undoOpCount = undoContext.getAll().size();
+            redoOpCount = undoContext.getRedoList().size();
+        } catch(DatabaseException e) {
+            e.printStackTrace();
+        }
+    }
+    
+    
+    
+    protected abstract void addActor(E node);
+    protected abstract void removeActor(E node);
+    protected abstract void updateActor(E node,Set<String> ids);
+    
+    public void repaint() {
+        view.refresh();
+    }
+    
+    public void populate() {
+        for (E node : rootNode.getNodes()) {
+            receiveAdd(node, node.getParentRel(),true);
+        }
+        repaint();
+    }
+    
+    @Override
+    public E getNode(vtkProp prop) {
+        return actorToNode.get(prop);
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Override
+    public Collection<vtkProp> getRenderObjects(INode node) {
+        return nodeToActor.getValues((E)node);
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Override
+    public ParentNode<E> getRootNode() {
+        return (ParentNode<E>)rootNode;
+    }
+    
+    
+    
+    @Override
+    public boolean isChangeTracking() {
+        return changeTracking;
+    }
+    
+    @Override
+    public void setChangeTracking(boolean enabled) {
+        changeTracking = enabled;
+    }
+    
+    private boolean changeTracking = true;
+    
+    protected Object syncMutex = new Object(); 
+    
 
-       private List<Pair<E,String>> added = new ArrayList<Pair<E,String>>();
-       private List<Pair<E,String>> removed = new ArrayList<Pair<E,String>>();
-       //private List<Pair<E,String>> updated = new ArrayList<Pair<E,String>>();
-       private MapSet<E, String> updated = new MapSet.Hash<E, String>();
+    private List<Pair<E,String>> added = new ArrayList<Pair<E,String>>();
+    private List<Pair<E,String>> removed = new ArrayList<Pair<E,String>>();
+    private MapSet<E, String> updated = new MapSet.Hash<E, String>();
 
-       private boolean rangeModified = false;
-       
-       @Override
-       public void onChanged() {
-           try {
-               int count = undoRedoSupport.getUndoContext(session).getAll().size();
-            if (count < undoOpCount) {
+    private boolean rangeModified = false;
+    
+    @Override
+    public void onChanged() {
+        try {
+            UndoContext undoContext = undoRedoSupport.getUndoContext(session);
+            int ucount = undoContext.getAll().size();
+            int rcount = undoContext.getRedoList().size();
+            if (DEBUG) System.out.println("Previous U:" + undoOpCount +" R:" + redoOpCount +" Current U:"+ucount+" R:"+rcount);
+            if (ucount < undoOpCount) {
                 runUndo = true;
             } else {
                 runUndo = false;
             }
-            undoOpCount = count;
-            if (DEBUG) System.out.println("Undo " + runUndo);
+            if (!runUndo && rcount > 0)
+                runRedo = true;
+            else
+                runRedo = false;
+            undoOpCount = ucount;
+            redoOpCount = rcount;
+            
+            if (DEBUG) System.out.println("Undo " + runUndo + " Redo " + runRedo);
         } catch (DatabaseException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
-           
-           
-       }
-       
-       @SuppressWarnings("unchecked")
-       @Override
-       public void updateRenderObjectsFor(INode node) {
-               List<vtkProp> toDelete = new ArrayList<vtkProp>();
-               view.lock();
-               for (vtkProp prop : nodeToActor.getValues((E)node)) {
-                       if (prop.GetVTKId() != 0) {
-                               view.getRenderer().RemoveActor(prop);
-                               //prop.Delete();
-                               toDelete.add(prop);
-                       }
-                       actorToNode.remove(prop);
-               }
-               view.unlock();
-               nodeToActor.remove((E)node);
-               Collection<vtkProp> coll = getActors((E)node);
-               if (coll == null)
-                       return;
-               for (vtkProp prop : coll) {
-                       nodeToActor.add((E)node,prop);
-                       actorToNode.put(prop, (E)node);
-                       toDelete.remove(prop);
-               }
-               for (vtkProp p : toDelete)
-                       p.Delete();
-       }
-       
-       protected abstract  Collection<vtkProp> getActors(E node);
-       
-       @SuppressWarnings("unchecked")
-       private void receiveAdd(E node, String id, boolean db) {
-               if (DEBUG) System.out.println("receiveAdd " + debugString(node)  + " " + id + " " + db);
-               synchronized (syncMutex) {
-                       for (Pair<E, String> n : added) {
-                               if (n.first.equals(node))
-                                       return;
-                       }
-                       if (changeTracking) {
-                               mapping.rangeModified((E)node.getParent());
-                       }
-                       added.add(new Pair<E, String>(node, id));
-                       rangeModified = true;
-               }
-               view.refresh();
-       }
-       
-       @SuppressWarnings("unchecked")
-       private void receiveRemove(E node, String id, boolean db) {
-               if (DEBUG) System.out.println("receiveRemove " + debugString(node)  + " " + id + " " + db);
-               synchronized (syncMutex) {
-                       for (Pair<E, String> n : removed) {
-                               if (n.first.equals(node))
-                                       return;
-                       }
-                       if (changeTracking && !db)
-                               mapping.rangeModified((E)node.getParent());
-                       removed.add(new Pair<E, String>(node, id));
-                       rangeModified = true;
-               }
-               view.refresh();
-       }
-       
-       @SuppressWarnings("unchecked")
-       private void receiveUpdate(E node, String id, boolean db) {
-               if (DEBUG) System.out.println("receiveUpdate " + debugString(node)  + " " + id + " " + db);
-               synchronized (syncMutex) {
-//                     for (Pair<E, String> n : updated) {
-//                             if (n.first.equals(node))
-//                                     return;
-//                     }
-                       if (changeTracking && !db)
-                               mapping.rangeModified(node);
-                       //updated.add(new Pair<E, String>(node, id));
-                       updated.add(node, id);
-                       rangeModified = true;
-               }
-               view.refresh();
-       }
-       
-       private boolean graphUpdates = false;
-       private Set<E> graphModified = new HashSet<E>();
-       
-       private boolean requestCommit = false;
-       private String commitMessage = null;
-       
-       @Override
-       public void commit(String message) {
-               requestCommit = true;
-               commitMessage = message;
-       }
-       
-       protected void doCommit() {
-               session.asyncRequest(new WriteRequest() {
-                       
-                       @Override
-                       public void perform(WriteGraph graph) throws DatabaseException {
-                           if (DEBUG) System.out.println("Commit " + commitMessage);
-                               if (commitMessage != null) {
-                                   Layer0Utils.addCommentMetadata(graph, commitMessage);
-                                   graph.markUndoPoint();
-                                   commitMessage = null;
-                               }
-                       commit(graph);
-                       }
-                       
-               }, new Callback<DatabaseException>() {
-                       
-                       @Override
-                       public void run(DatabaseException parameter) {
-                               if (parameter != null)
-                                       ExceptionUtils.logAndShowError("Cannot commit editor changes", parameter);
-                       }
-               });
-       }
-       
-       protected void commit(WriteGraph graph) throws DatabaseException {
-               synchronized(syncMutex) {
-                       if (DEBUG) System.out.println("Commit");
-                       graphUpdates = true;
-                       mapping.updateDomain(graph);
-                       graphUpdates = false;
-                       clearDeletes();
-               if (DEBUG) System.out.println("Commit done");
-               }
-       }
-       
-       
-       
-       @Override
-       public void domainModified() {
-               if (graphUpdates)
-                       return;
-               if (DEBUG)System.out.println("domainModified");
-               session.asyncRequest(new ReadRequest() {
-                       
-                       @SuppressWarnings("unchecked")
-                       @Override
-                       public void run(ReadGraph graph) throws DatabaseException {
-                               update(graph);
-                       }
-               });
-               
-       }
-       
-       protected void reset(ReadGraph graph) throws MappingException {
-           if (DEBUG) System.out.println("Reset");
+        
+        
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Override
+    public void updateRenderObjectsFor(E node) {
+        List<vtkProp> toDelete = new ArrayList<vtkProp>();
+        view.lock();
+        for (vtkProp prop : nodeToActor.getValues((E)node)) {
+            if (prop.GetVTKId() != 0) {
+                view.getRenderer().RemoveActor(prop);
+                //prop.Delete();
+                toDelete.add(prop);
+            }
+            actorToNode.remove(prop);
+        }
+        view.unlock();
+        nodeToActor.remove((E)node);
+        Collection<vtkProp> coll = getActors((E)node);
+        if (coll != null) {
+            for (vtkProp prop : coll) {
+                nodeToActor.add((E)node,prop);
+                actorToNode.put(prop, (E)node);
+                toDelete.remove(prop);
+            }
+        }
+        for (vtkProp p : toDelete)
+            p.Delete();
+    }
+    
+    protected abstract  Collection<vtkProp> getActors(E node);
+    
+    @SuppressWarnings("unchecked")
+    private void receiveAdd(E node, String id, boolean db) {
+        if (DEBUG) System.out.println("receiveAdd " + debugString(node)  + " " + id + " " + db);
+        synchronized (syncMutex) {
+            for (Pair<E, String> n : added) {
+                if (n.first.equals(node))
+                    return;
+            }
+            if (changeTracking) {
+                mapping.rangeModified((E)node.getParent());
+            }
+            added.add(new Pair<E, String>(node, id));
+            rangeModified = true;
+        }
+        view.refresh();
+    }
+    
+    @SuppressWarnings("unchecked")
+    private void receiveRemove(E node, String id, boolean db) {
+        if (DEBUG) System.out.println("receiveRemove " + debugString(node)  + " " + id + " " + db);
+        synchronized (syncMutex) {
+            for (Pair<E, String> n : removed) {
+                if (n.first.equals(node))
+                    return;
+            }
+            if (changeTracking && !db)
+                mapping.rangeModified((E)node.getParent());
+            removed.add(new Pair<E, String>(node, id));
+            rangeModified = true;
+        }
+        repaint();
+    }
+    
+    @SuppressWarnings("unchecked")
+    private void receiveUpdate(E node, String id, boolean db) {
+        if (DEBUG) System.out.println("receiveUpdate " + debugString(node)  + " " + id + " " + db);
+        synchronized (syncMutex) {
+//          for (Pair<E, String> n : updated) {
+//              if (n.first.equals(node))
+//                  return;
+//          }
+            if (changeTracking && !db)
+                mapping.rangeModified(node);
+            //updated.add(new Pair<E, String>(node, id));
+            updated.add(node, id);
+            rangeModified = true;
+        }
+        repaint();
+    }
+    
+    private boolean graphUpdates = false;
+    private Set<E> graphModified = new HashSet<E>();
+    
+    private boolean requestCommit = false;
+    private String commitMessage = null;
+    
+    @Override
+    public void commit(String message) {
+        requestCommit = true;
+        commitMessage = message;
+    }
+    
+    protected void doCommit() {
+        session.asyncRequest(new WriteRequest() {
+            
+            @Override
+            public void perform(WriteGraph graph) throws DatabaseException {
+                if (DEBUG) System.out.println("Commit " + commitMessage);
+                if (commitMessage != null) {
+                    Layer0Utils.addCommentMetadata(graph, commitMessage);
+                    graph.markUndoPoint();
+                    commitMessage = null;
+                }
+                commit(graph);
+            }
+            
+        }, new Callback<DatabaseException>() {
+            
+            @Override
+            public void run(DatabaseException parameter) {
+                if (parameter != null)
+                    ExceptionUtils.logAndShowError("Cannot commit editor changes", parameter);
+            }
+        });
+    }
+    
+    protected void commit(WriteGraph graph) throws DatabaseException {
+        synchronized(syncMutex) {
+            if (DEBUG) System.out.println("Commit");
+            graphUpdates = true;
+            mapping.updateDomain(graph);
+            graphUpdates = false;
+            clearDeletes();
+            if (DEBUG) System.out.println("Commit done");
+        }
+    }
+    
+    
+    
+    @Override
+    public void domainModified() {
+        if (graphUpdates)
+            return;
+        if (DEBUG)System.out.println("domainModified");
+        session.asyncRequest(new ReadRequest() {
+            
+            @SuppressWarnings("unchecked")
+            @Override
+            public void run(ReadGraph graph) throws DatabaseException {
+                update(graph);
+            }
+        });
+        
+    }
+    
+    protected void reset(ReadGraph graph) throws MappingException {
+        if (DEBUG) System.out.println("Reset");
         synchronized (syncMutex) {
             graphUpdates = true;
             mapping.getRangeModified().clear();
@@ -311,78 +324,77 @@ public abstract class AbstractVTKNodeMap<E extends INode> implements VTKNodeMap<
             graphModified.clear();
             graphUpdates = false;
         }
-       }
-       
-       private boolean useFullSyncWithUndo = false;
-       
-       protected void update(ReadGraph graph) throws DatabaseException {
-           if (DEBUG) System.out.println("Graph update start");
-           if (runUndo && useFullSyncWithUndo) {
-               reset(graph);
-           } else {
-               synchronized (syncMutex) {
-                       graphUpdates = true;
-                       for (Object domainObject : mapping.getDomainModified()) {
-                               E rangeObject = mapping.get(domainObject);
-                               if (rangeObject != null)
-                                       graphModified.add(rangeObject);
-                       }
-                       mapping.updateRange(graph);
-                       graphModified.clear();
-                       syncDeletes();
-                       clearDeletes();
-                       graphUpdates = false;
-               }
-           }
-               
-               //if (mapping.isRangeModified() && !runUndo) // FIXME : redo?
-           if (mapping.isRangeModified())
-                       commit((String)null);
-               if (DEBUG) System.out.println("Graph update done");
-       }
-       
-       @Override
-       public void rangeModified() {
-               //System.out.println("rangeModified");
+    }
+    
+    private boolean useFullSyncWithUndo = false;
+    
+    protected void update(ReadGraph graph) throws DatabaseException {
+        if (DEBUG) System.out.println("Graph update start");
+        if (runUndo && useFullSyncWithUndo) {
+            reset(graph);
+        } else {
+            synchronized (syncMutex) {
+                graphUpdates = true;
+                for (Object domainObject : mapping.getDomainModified()) {
+                    E rangeObject = mapping.get(domainObject);
+                    if (rangeObject != null)
+                        graphModified.add(rangeObject);
+                }
+                mapping.updateRange(graph);
+                graphModified.clear();
+                syncDeletes();
+                clearDeletes();
+                graphUpdates = false;
+            }
+        }
+        
+        if (mapping.isRangeModified() && !runUndo && !runRedo)
+            commit((String)null);
+        if (DEBUG) System.out.println("Graph update done");
+    }
+    
+    @Override
+    public void rangeModified() {
+        //System.out.println("rangeModified");
 
-       }
-       
-       @Override
-       public void postRender() {
-               // Commit changes if
-               // 1. Commit has been requested
-               // 2. There are no pending changes that should be processed in preRender() 
-               if (requestCommit && !rangeModified) { // FIXME : not thread safe.
-                       requestCommit = false;
-                       doCommit();
-               }
-       }
-       
-       // Reusable containers for data synchronisation
-       List<Pair<E, String>> rem = new ArrayList<Pair<E,String>>();  // Removed objects
-       List<Pair<E, String>> add = new ArrayList<Pair<E,String>>();  // Added objects
-       MapSet<E, String> mod = new MapSet.Hash<E, String>();         // Modified objects
-       Set<E> propagation = new HashSet<E>();                        // Objects with propagated changes 
-       Stack<E> stack = new Stack<E>();                              // Stack for handling propagation
-       Set<E> delete = Collections.synchronizedSet(new HashSet<E>()); // Objects to be completely deleted
-       Set<E> deleteUC = new HashSet<E>();
-       
-       @Override
-       public synchronized void preRender() {
-               updateCycle();
-       }
-       
-       
-       /**
-        * When objects are removed (either from Java or Graph), after remove processing the Java objects remain in mapping cache.
-        * This causes problems with Undo and Redo, whcih the end up re-using the removed objects from mapping cache.
-        
-        * This code here synchronizes removed and added objects to collect deletable objects. (a deletable object is one which is removed but not added).  
-        
-        */
-       protected void syncDeletes() {
-           deleteUC.clear();
-           for (Pair<E, String> n : removed) {
+    }
+    
+    @Override
+    public void postRender() {
+        // Commit changes if
+        // 1. Commit has been requested
+        // 2. There are no pending changes that should be processed in preRender() 
+        if (requestCommit && !rangeModified) { // FIXME : not thread safe.
+            requestCommit = false;
+            doCommit();
+        }
+    }
+    
+    // Reusable containers for data synchronisation
+    List<Pair<E, String>> rem = new ArrayList<Pair<E,String>>();  // Removed objects
+    List<Pair<E, String>> add = new ArrayList<Pair<E,String>>();  // Added objects
+    MapSet<E, String> mod = new MapSet.Hash<E, String>();         // Modified objects
+    Set<E> propagation = new HashSet<E>();                        // Objects with propagated changes 
+    Stack<E> stack = new Stack<E>();                              // Stack for handling propagation
+    Set<E> delete = Collections.synchronizedSet(new HashSet<E>()); // Objects to be completely deleted
+    Set<E> deleteUC = new HashSet<E>();
+    
+    @Override
+    public synchronized void preRender() {
+        updateCycle();
+    }
+    
+    
+    /**
+     * When objects are removed (either from Java or Graph), after remove processing the Java objects remain in mapping cache.
+     * This causes problems with Undo and Redo, whcih the end up re-using the removed objects from mapping cache.
+     * 
+     * This code here synchronizes removed and added objects to collect deletable objects. (a deletable object is one which is removed but not added).  
+     * 
+     */
+    protected void syncDeletes() {
+        deleteUC.clear();
+        for (Pair<E, String> n : removed) {
             deleteUC.add(n.first);   
          }
          for (Pair<E, String> n : added) {
@@ -396,12 +408,12 @@ public abstract class AbstractVTKNodeMap<E extends INode> implements VTKNodeMap<
          }
          delete.addAll(deleteUC);
          deleteUC.clear();
-       }
-       
-       /**
-        * Clears deletable objects from mapping cache.
-        */
-       protected void clearDeletes() {
+    }
+    
+    /**
+     * Clears deletable objects from mapping cache.
+     */
+    protected void clearDeletes() {
         if (DEBUG && delete.size() > 0) System.out.println("Delete");
         for (E n : delete) {
             if (DEBUG) System.out.println(debugString(n));
@@ -409,212 +421,212 @@ public abstract class AbstractVTKNodeMap<E extends INode> implements VTKNodeMap<
         }
         delete.clear();
     }
-       
-       protected String debugString(E n) {
-           return n + "@" + Integer.toHexString(n.hashCode());
-       }
-       
-       @SuppressWarnings("unchecked")
-       protected void updateCycle() {
-               rem.clear();
-               add.clear();
-               mod.clear();
-               propagation.clear();
-               
-               
-               synchronized (syncMutex) {
-                       rem.addAll(removed);
-                       add.addAll(added);
-                       for (E e : updated.getKeys()) {
-                               for (String s : updated.getValues(e)) {
-                                       mod.add(e, s);
-                               }
-                       }
-                       syncDeletes();
-                       removed.clear();
-                       added.clear();
-                       updated.clear();
-               }
-               
-               for (Pair<E, String> n : rem) {
-                       stopListening(n.first);
-                       removeActor(n.first);
-               }
-               
-               for (Pair<E, String> n : add) {
-                       addActor(n.first);
-                       listen(n.first);
-               }
-               
-               for (E e : mod.getKeys()) {
-                       Set<String> ids = mod.getValues(e);
-                       if (ids.contains(G3D.URIs.hasPosition) || ids.contains(G3D.URIs.hasOrientation)) {
-                               if (!propagation.contains(e))
-                                       propagation.add(e);
-                       }
-               }
+    
+    protected String debugString(E n) {
+        return n + "@" + Integer.toHexString(n.hashCode());
+    }
+    
+    @SuppressWarnings("unchecked")
+    protected void updateCycle() {
+        rem.clear();
+        add.clear();
+        mod.clear();
+        propagation.clear();
+        
+        
+        synchronized (syncMutex) {
+            rem.addAll(removed);
+            add.addAll(added);
+            for (E e : updated.getKeys()) {
+                for (String s : updated.getValues(e)) {
+                    mod.add(e, s);
+                }
+            }
+            syncDeletes();
+            removed.clear();
+            added.clear();
+            updated.clear();
+        }
+        
+        for (Pair<E, String> n : rem) {
+            stopListening(n.first);
+            removeActor(n.first);
+        }
+        
+        for (Pair<E, String> n : add) {
+            addActor(n.first);
+            listen(n.first);
+        }
+        
+        for (E e : mod.getKeys()) {
+            Set<String> ids = mod.getValues(e);
+            if (ids.contains(G3D.URIs.hasPosition) || ids.contains(G3D.URIs.hasOrientation)) {
+                if (!propagation.contains(e))
+                    propagation.add(e);
+            }
+        }
 
-               if (propagation.size() > 0) {
-                       stack.clear();
-                       stack.addAll(propagation);
-                       propagation.clear();
-                       while (!stack.isEmpty()) {
-                               E node = stack.pop();
-                               if (propagation.contains(node))
-                                       continue;
-                               propagation.add(node);
-                               for (NodeListener l : node.getListeners()) {
-                                       if (l == this) {
-                                               //changeTracking = false;
-                                               //l.propertyChanged(node, G3D.URIs.hasPosition);
-                                               //changeTracking = true;
-                                       } else {
-                                               l.propertyChanged(node, G3D.URIs.hasWorldPosition);
-                                       }
-                               }
-                               if (node instanceof ParentNode) {
-                                       stack.addAll(((ParentNode<E>)node).getNodes());
-                               }
-                       }
-               }
-               
-//             synchronized (syncMutex) {
-//                     rem.addAll(removed);
-//                     add.addAll(added);
-//                     //mod.addAll(updated);
-//                     for (E e : updated.getKeys()) {
-//                             for (String s : updated.getValues(e))
-//                                     mod.add(e, s);
-//                     }
-//                     
-//                     removed.clear();
-//                     added.clear();
-//                     updated.clear();
-//             }
-               
-               for (E e : mod.getKeys()) {
-                       Set<String> ids = mod.getValues(e);
-                       updateActor(e,ids);
-               }
-               
-               
-               for (Pair<E, String> n : rem) {
-                       for (NodeListener l : nodeListeners)
-                               l.nodeRemoved(null, n.first, n.second);
-               }
-               for (Pair<E, String> n : add) {
-                       for (NodeListener l : nodeListeners)
-                               l.nodeAdded(n.first.getParent(), n.first, n.second);
-               }
-//             for (Pair<E, String> n : mod) {
-//                     for (NodeListener l : nodeListeners)
-//                             l.propertyChanged(n.first, n.second);
-//             }
-               for (E e : mod.getKeys()) {
-                       for (NodeListener l : nodeListeners)
-                               for (String s : mod.getValues(e))
-                                       l.propertyChanged(e, s);
-               }
-               
-               synchronized (syncMutex) {
-                   if (added.isEmpty() && removed.isEmpty() && updated.getKeys().size() == 0)
-                               rangeModified = false;
-               }
-       }
-       
-       @SuppressWarnings("unchecked")
-       private void listen(INode node) {
-               node.addListener(this);
-               if (node instanceof ParentNode<?>) {
-                       ParentNode<INode> parentNode = (ParentNode<INode>)node;
-                       for (INode n : parentNode.getNodes())
-                               listen(n);
-               }
-       }
-       
-       private void stopListening(INode node) {
-               node.removeListener(this);
-               if (node instanceof ParentNode<?>) {
-                       @SuppressWarnings("unchecked")
-                       ParentNode<INode> parentNode = (ParentNode<INode>)node;
-                       for (INode n : parentNode.getNodes())
-                               stopListening(n);
-               }
-       }
-       
-       @SuppressWarnings("unchecked")
-       @Override
-       public void propertyChanged(INode node, String id) {
-               //receiveUpdate((E)node, id, graphUpdates);
-               receiveUpdate((E)node, id, graphModified.contains(node));
-               
-       }
-       
-       @SuppressWarnings("unchecked")
-       @Override
-       public <T extends INode> void nodeAdded(ParentNode<T> node, INode child,
-                       String rel) {
-               if (DEBUG) System.out.println("Node added " + child + " parent " + node);
-               //receiveAdd((E)child, rel ,graphUpdates);
-               receiveAdd((E)child, rel ,graphModified.contains(node));
-               
-       }
-       
-       @SuppressWarnings("unchecked")
-       @Override
-       public <T extends INode> void nodeRemoved(ParentNode<T> node, INode child,
-                       String rel) {
-               if (DEBUG) System.out.println("Node removed " + child + " parent " + node);
-               //receiveRemove((E)child, rel, graphUpdates);
-               receiveRemove((E)child, rel, graphModified.contains(node));
-               
-               //FIXME : sometimes removed structural models cause ObjMap to add their children again.
-               //        removing the listener here prevents corruption of visual model, but better fix is needed.
-               stopListening(child);
-       }
-       
-       @Override
-       public void delete() {
-           if (undoRedoSupport != null)
-               undoRedoSupport.cancel(this);
+        if (propagation.size() > 0) {
+            stack.clear();
+            stack.addAll(propagation);
+            propagation.clear();
+            while (!stack.isEmpty()) {
+                E node = stack.pop();
+                if (propagation.contains(node))
+                    continue;
+                propagation.add(node);
+                for (NodeListener l : node.getListeners()) {
+                    if (l == this) {
+                        //changeTracking = false;
+                        //l.propertyChanged(node, G3D.URIs.hasPosition);
+                        //changeTracking = true;
+                    } else {
+                        l.propertyChanged(node, G3D.URIs.hasWorldPosition);
+                    }
+                }
+                if (node instanceof ParentNode) {
+                    stack.addAll(((ParentNode<E>)node).getNodes());
+                }
+            }
+        }
+        
+//      synchronized (syncMutex) {
+//          rem.addAll(removed);
+//          add.addAll(added);
+//          //mod.addAll(updated);
+//          for (E e : updated.getKeys()) {
+//              for (String s : updated.getValues(e))
+//                  mod.add(e, s);
+//          }
+//          
+//          removed.clear();
+//          added.clear();
+//          updated.clear();
+//      }
         
-               changeTracking = false;
-               view.removeListener(this);
-               mapping.removeMappingListener(this);
+        for (E e : mod.getKeys()) {
+            Set<String> ids = mod.getValues(e);
+            updateActor(e,ids);
+        }
+        
+        
+        for (Pair<E, String> n : rem) {
+            for (NodeListener l : nodeListeners)
+                l.nodeRemoved(null, n.first, n.second);
+        }
+        for (Pair<E, String> n : add) {
+            for (NodeListener l : nodeListeners)
+                l.nodeAdded(n.first.getParent(), n.first, n.second);
+        }
+//      for (Pair<E, String> n : mod) {
+//          for (NodeListener l : nodeListeners)
+//              l.propertyChanged(n.first, n.second);
+//      }
+        for (E e : mod.getKeys()) {
+            for (NodeListener l : nodeListeners)
+                for (String s : mod.getValues(e))
+                    l.propertyChanged(e, s);
+        }
+        
+        synchronized (syncMutex) {
+            if (added.isEmpty() && removed.isEmpty() && updated.getKeys().size() == 0)
+                rangeModified = false;
+        }
+    }
+    
+    @SuppressWarnings("unchecked")
+    private void listen(INode node) {
+        node.addListener(this);
+        if (node instanceof ParentNode<?>) {
+            ParentNode<INode> parentNode = (ParentNode<INode>)node;
+            for (INode n : parentNode.getNodes())
+                listen(n);
+        }
+    }
+    
+    private void stopListening(INode node) {
+        node.removeListener(this);
+        if (node instanceof ParentNode<?>) {
+            @SuppressWarnings("unchecked")
+            ParentNode<INode> parentNode = (ParentNode<INode>)node;
+            for (INode n : parentNode.getNodes())
+                stopListening(n);
+        }
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Override
+    public void propertyChanged(INode node, String id) {
+        //receiveUpdate((E)node, id, graphUpdates);
+        receiveUpdate((E)node, id, graphModified.contains(node));
+        
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T extends INode> void nodeAdded(ParentNode<T> node, INode child,
+            String rel) {
+        if (DEBUG) System.out.println("Node added " + child + " parent " + node);
+        //receiveAdd((E)child, rel ,graphUpdates);
+        receiveAdd((E)child, rel ,graphModified.contains(node));
+        
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T extends INode> void nodeRemoved(ParentNode<T> node, INode child,
+            String rel) {
+        if (DEBUG) System.out.println("Node removed " + child + " parent " + node);
+        //receiveRemove((E)child, rel, graphUpdates);
+        receiveRemove((E)child, rel, graphModified.contains(node));
+        
+        //FIXME : sometimes removed structural models cause ObjMap to add their children again.
+        //        removing the listener here prevents corruption of visual model, but better fix is needed.
+        stopListening(child);
+    }
+    
+    @Override
+    public void delete() {
+        if (undoRedoSupport != null)
+            undoRedoSupport.cancel(this);
+        
+        changeTracking = false;
+        view.removeListener(this);
+        mapping.removeMappingListener(this);
 
-               List<E> nodes = new ArrayList<E>(nodeToActor.getKeySize());
-               nodes.addAll(nodeToActor.getKeys());
-               for (E node : nodes) {
-                       node.removeListener(this);
-                       removeActor(node);
-                       node.cleanup();
-               }
-               for (vtkProp prop : actorToNode.keySet()) {
-                       if (prop.GetVTKId() != 0) 
-                               prop.Delete();
-               }
-               actorToNode.clear();
-               nodeToActor.clear();
-               
-       }
-       
-       
-       private List<NodeListener> nodeListeners = new ArrayList<NodeListener>();
-       @Override
-       public void addListener(NodeListener listener) {
-               nodeListeners.add(listener);
-               
-       }
-       
-       @Override
-       public void removeListener(NodeListener listener) {
-               nodeListeners.remove(listener);
-               
-       }
-       
-       public IMapping<Object,E> getMapping() {
-               return mapping;
-       }
-       
-       
+        List<E> nodes = new ArrayList<E>(nodeToActor.getKeySize());
+        nodes.addAll(nodeToActor.getKeys());
+        for (E node : nodes) {
+            node.removeListener(this);
+            removeActor(node);
+            node.cleanup();
+        }
+        for (vtkProp prop : actorToNode.keySet()) {
+            if (prop.GetVTKId() != 0) 
+                prop.Delete();
+        }
+        actorToNode.clear();
+        nodeToActor.clear();
+        
+    }
+    
+    
+    private List<NodeListener> nodeListeners = new ArrayList<NodeListener>();
+    @Override
+    public void addListener(NodeListener listener) {
+        nodeListeners.add(listener);
+        
+    }
+    
+    @Override
+    public void removeListener(NodeListener listener) {
+        nodeListeners.remove(listener);
+        
+    }
+    
+    public IMapping<Object,E> getMapping() {
+        return mapping;
+    }
+    
+    
 }
index 3d85ef02316220ab5c122d85bdfff693b6867b03..a3ddc06509c6d589a2ac6a29743ac37dc0e12c41 100644 (file)
@@ -1,17 +1,18 @@
-###############################################################################\r
-# Copyright (c) 2012, 2013 Association for Decentralized Information Management in\r
-# Industry THTH ry.\r
-# All rights reserved. This program and the accompanying materials\r
-# are made available under the terms of the Eclipse Public License v1.0\r
-# which accompanies this distribution, and is available at\r
-# http://www.eclipse.org/legal/epl-v10.html\r
-#\r
-# Contributors:\r
-#     VTT Technical Research Centre of Finland - initial API and implementation\r
-###############################################################################\r
-source.. = src/\r
-output.. = bin/\r
-bin.includes = META-INF/,\\r
-               .,\\r
-               plugin.xml,\\r
-               adapters.xml\r
+###############################################################################
+# Copyright (c) 2012, 2013 Association for Decentralized Information Management in
+# Industry THTH ry.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+#     VTT Technical Research Centre of Finland - initial API and implementation
+###############################################################################
+source.. = src/
+output.. = bin/
+bin.includes = META-INF/,\
+               .,\
+               plugin.xml,\
+               adapters.xml,\
+               scl/
index c6d4e0ab7473dec98c2a15db9c8734b4a1c8e1ef..99c99a50c808d4955eabc8e2ea0848ca1c4f8733 100644 (file)
@@ -4,4 +4,5 @@ bin.includes = META-INF/,\
                .,\
                plugin.xml,\
                adapters.xml,\
-               icons/
+               icons/,\
+               scl/