PipeCOntrolPoint setNext/setPrev/remove improved

Mentioned methods can now handle size change / offset points directly.
Previous implementation could not handle two reducers connected to each
other.

gitlab #35

Change-Id: I817a4d75290b184f772965ff38c01b3e9ae61c64

diff --git a/org.simantics.plant3d/src/org/simantics/plant3d/actions/RoutePipeAction.java b/org.simantics.plant3d/src/org/simantics/plant3d/actions/RoutePipeAction.java
index a57fcc4c0be6d4e48db55f71710e2c1515f18be8..9f523c956be2b8ac7c08cb2f15740e45dc67c380 100644 (file)
--- a/org.simantics.plant3d/src/org/simantics/plant3d/actions/RoutePipeAction.java
+++ b/org.simantics.plant3d/src/org/simantics/plant3d/actions/RoutePipeAction.java
@@ -310,7 +310,7 @@ public class RoutePipeAction extends vtkSwtAction {
        
        protected void activateNextPrev(PipeControlPoint start) throws Exception{
                if (!reversed && start.isDualInline())
-                       start = start.getSubPoint().get(0);
+                       start = start.getDualSub();
                else if (reversed && start.isDualSub())
                        start = start.parent;
                
@@ -1050,21 +1050,29 @@ public class RoutePipeAction extends vtkSwtAction {
        private PipeControlPoint endingToComponent(INode componentNode, Vector3d o, Vector3d d) {
                PipelineComponent component = (PipelineComponent)componentNode;
                PipeControlPoint pcp = component.getControlPoint();
+               PipeControlPoint connect = null;
                if (component instanceof EndComponent) {
                        if (pcp.getNext() != null || pcp.getPrevious() != null)
                                return null;
-                       return pcp;
+                       connect =  pcp;
                } else if (component instanceof TurnComponent) {
                        if (pcp.getNext() == null || pcp.getPrevious() == null)
-                               return pcp;
-                       return null;
+                               connect = pcp;
+                       else
+                           return null;
                } else if (component instanceof InlineComponent) {
                        // TODO : scan all empty pcps of the component and select closest one.
                        if (pcp.getNext() == null || pcp.getPrevious() == null)
-                               return pcp;
-                       return null;
+                               connect =  pcp;
+                       else
+                           return null;
+               }
+               if (connect != null) {
+                   currentPosition.set(connect.getWorldPosition());
+            updateCurrentPoint();
+                   setInfoText("Connect to " + component.getName());
+                   return connect;
                }
-
                return null;
        }
        

diff --git a/org.simantics.plant3d/src/org/simantics/plant3d/actions/TranslateFreeVariableLengthAction.java b/org.simantics.plant3d/src/org/simantics/plant3d/actions/TranslateFreeVariableLengthAction.java
index 261ab8c36d88dd2ec8c092a579838e1db9764134..b76989e1caace5bd31aa5e9e878e714dd7eea616 100644 (file)
--- a/org.simantics.plant3d/src/org/simantics/plant3d/actions/TranslateFreeVariableLengthAction.java
+++ b/org.simantics.plant3d/src/org/simantics/plant3d/actions/TranslateFreeVariableLengthAction.java
@@ -64,7 +64,7 @@ public class TranslateFreeVariableLengthAction extends RoutePipeAction{
     @Override
     protected void activateNextPrev(PipeControlPoint start) throws Exception {
         if (!reversed && start.isDualInline())
-            start = start.getSubPoint().get(0);
+            start = start.getDualSub();
         else if (reversed && start.isDualSub())
             start = start.parent;
         

diff --git a/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/InlineComponent.java b/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/InlineComponent.java
index 3ec6b3547c317c5022a5bac7804e4288eef7e096..d3e8742c9db93019bc3fe8d087d146a8fa5c2bb8 100644 (file)
--- a/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/InlineComponent.java
+++ b/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/InlineComponent.java
@@ -120,16 +120,21 @@ public class InlineComponent extends PipelineComponent {
        public void updateParameters() {
                super.updateParameters();
                if (!isVariableLength()) {
-                       Map<String,Object> calculated = getTotalParameters();
-                       if (calculated.containsKey("length")) {
-                               controlPoint.setLength((Double)calculated.get("length"));
-                       }
+                       Map<String,Object> calculated = getCalculatedParameters();
+                       
                        if (calculated.containsKey("offset")) {
                                controlPoint.setOffset((Double)calculated.get("offset"));
                                componentCalculatedOffset = true;
                        } else {
                                componentCalculatedOffset = false;
                        }
+                       
+                       Map<String,Object> total = getTotalParameters();
+                       
+                       if (total.containsKey("length")) {
+                controlPoint.setLength((Double)total.get("length"));
+            }
+                       
                        PipingRules.requestUpdate(getControlPoint());
                }
        }
@@ -165,7 +170,7 @@ public class InlineComponent extends PipelineComponent {
                        if (!Double.isNaN(controlPoint.getLength()) && controlPoint.isVariableLength())
                                map.put("length", controlPoint.getLength());
                        if (controlPoint.isDualInline()) {
-                               PipeControlPoint sub = controlPoint.getSubPoint().get(0);
+                               PipeControlPoint sub = controlPoint.getDualSub();
                                PipeRun pipeRun2 = sub.getPipeRun();
                                if (pipeRun2 != null) {
                                        map.put("radius2", pipeRun2.getPipeDiameter() * 0.5);

diff --git a/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/PipelineComponent.java b/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/PipelineComponent.java
index 37dd50124b220c8a9848bf008eafd2df97782288..b052bae435d2a25d8061e29881717b007656f237 100644 (file)
--- a/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/PipelineComponent.java
+++ b/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/PipelineComponent.java
@@ -78,9 +78,16 @@ public abstract class PipelineComponent extends GeometryNode {
                        return;
                this.alternativePipeRun = pipeRun;
                if (getControlPoint().isDualInline()) {
-                       PipeControlPoint sub = getControlPoint().getSubPoint().get(0);
-                       if (sub.getParent() != this.alternativePipeRun)
-                               this.alternativePipeRun.addChild(sub);
+                       PipeControlPoint sub = getControlPoint().getDualSub();
+                       if (sub.getParent() != this.alternativePipeRun) {
+                           if (this.alternativePipeRun != null) {
+                              this.alternativePipeRun.addChild(sub);
+                           } else if (sub.getPipeRun() != null) {
+                               // FIXME : how to handle child point without proper run?
+                               sub.getPipeRun().remChild(sub);
+                           }
+                       }
+                               
                }
                firePropertyChanged(Plant3D.URIs.HasAlternativePipeRun);
        }
@@ -221,8 +228,8 @@ public abstract class PipelineComponent extends GeometryNode {
        
        private PipeControlPoint getBranchPoint() {
                PipeControlPoint branchPoint;
-               if (getControlPoint().getSubPoint().size() > 0) {
-                       branchPoint = getControlPoint().getSubPoint().get(0);
+               if (getControlPoint().getChildPoints().size() > 0) {
+                       branchPoint = getControlPoint().getChildPoints().get(0);
                } else {
                        if (branch0.getPipeRun() == null)
                                return null;
@@ -243,27 +250,27 @@ public abstract class PipelineComponent extends GeometryNode {
                if (pcp.getNext() != nextPCP) {
                        pcp.setNext(nextPCP);
                }
-               if (pcp.isDualInline()) {
-                       PipeControlPoint sub = pcp.getSubPoint().get(0);
-                       if (sub.getNext() != nextPCP)
-                               sub.setNext(nextPCP);
-               }
+//             if (pcp.isDualInline()) {
+//                     PipeControlPoint sub = pcp.getChildPoints().get(0);
+//                     if (sub.getNext() != nextPCP)
+//                             sub.setNext(nextPCP);
+//             }
                return true;
        }
        
        private boolean  _connectPrev(PipeControlPoint pcp, PipeControlPoint prevPCP) {
                if (prevPCP == null)
                        return false;
-               if (prevPCP.isDualInline())
-                       prevPCP = prevPCP.getSubPoint().get(0);
+//             if (prevPCP.isDualInline())
+//                     prevPCP = prevPCP.getChildPoints().get(0);
                if (pcp.getPrevious() != prevPCP) {
                        pcp.setPrevious(prevPCP);
                }
-               if (pcp.isDualInline()) {
-                       PipeControlPoint sub = pcp.getSubPoint().get(0);
-                       if (sub.getPrevious() != prevPCP)
-                               sub.setPrevious(prevPCP);
-               }
+//             if (pcp.isDualInline()) {
+//                     PipeControlPoint sub = pcp.getChildPoints().get(0);
+//                     if (sub.getPrevious() != prevPCP)
+//                             sub.setPrevious(prevPCP);
+//             }
                return true;
        }
        
@@ -401,7 +408,7 @@ public abstract class PipelineComponent extends GeometryNode {
                                        return false;
                                }
                                
-                       } else if (getControlPoint().getSubPoint().size() > 0) { // TODO : this may cause problems? (Removes branch point, before branch has been set?)
+                       } else if (getControlPoint().getChildPoints().size() > 0) { // TODO : this may cause problems? (Removes branch point, before branch has been set?)
                                //getControlPoint().getSubPoint().get(0).remove();
                                //getControlPoint().children.clear();
                                return true;

diff --git a/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/controlpoint/PipeControlPoint.java b/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/controlpoint/PipeControlPoint.java
index 086bdb2b5d408de5fcc8109dba50eae6ea8ca452..491a273331a36ec8a0392122c92dc8833c6bbfb6 100644 (file)
--- a/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/controlpoint/PipeControlPoint.java
+++ b/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/controlpoint/PipeControlPoint.java
@@ -40,7 +40,7 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
        private boolean isReverse = false;     // definition direction can be swapped
        private boolean isDeletable = true;    // can be removed by rules
        private boolean isSizeChange = false;  // changes size of the pipe. The next control point / component is on different PipeRun
-       private boolean isSub = false;         // child point
+       private boolean isSub = false;         // child point for offset / size change
 
        public PipeControlPoint(PipelineComponent component) {
                this.component = component;
@@ -233,12 +233,44 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
        }
 
        public void setNext(PipeControlPoint next) {
+           if (isSub) {
+               getParentPoint().setNext(next);
+               return;
+           }
+           if (next != null && next.isDualSub())
+               next = next.parent;
+           if (_setNext(next)) {
+               for (PipeControlPoint pcp : children) {
+                if (pcp.isSub)
+                    pcp._setNext(next);
+            }
+               updateSubPoint();
+           }
+       }
+       
+       public void setPrevious(PipeControlPoint prev) {
+        if (isSub) {
+            getParentPoint().setPrevious(prev);
+            return;
+        }
+        if (prev != null && prev.isDualInline())
+            prev = prev.children.get(0);
+        if (_setPrevious(prev)) {
+            for (PipeControlPoint pcp : children) {
+                if (pcp.isSub)
+                    pcp._setPrevious(prev);
+            }
+            updateSubPoint();
+        }
+    }
+       
+       protected boolean _setNext(PipeControlPoint next) {
                if (isEnd() && previous != null && next != null)
                        throw new RuntimeException("End control points are allowed to have only one connection");
                if (next == this)
                        throw new RuntimeException("Cannot connect to self");
                if (this.next == next)
-                       return;
+                       return false;
                if (DEBUG) System.out.println(this + " next " + next);
                if (next == null && isVariableAngle() && previous != null && !isRemoved()) {
                    convertVariableAngleToFixed(Direction.NEXT);
@@ -249,17 +281,18 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
                                component.setNext(next != null ? next.component : null);
                        else
                                component.setBranch0(next != null ? next.component : null);
-                       updateSubPoint();
+                       
                }
+               return true;
        }
 
-       public void setPrevious(PipeControlPoint previous) {
+       protected boolean _setPrevious(PipeControlPoint previous) {
                if (isEnd() && next != null && previous != null)
                        throw new RuntimeException("End control points are allowed to have only one connection");
                if (previous == this)
                        throw new RuntimeException("Cannot connect to self");
                if (this.previous == previous)
-                       return;
+                       return false;
                if (DEBUG) System.out.println(this + " previous " + previous);
                if (previous == null && isVariableAngle() && next != null && !isRemoved()) {
             convertVariableAngleToFixed(Direction.PREVIOUS);
@@ -272,6 +305,7 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
                                component.setBranch0(previous != null ? previous.component : null);
                        updateSubPoint();
                }
+               return true;
        }
        
        private void convertVariableAngleToFixed(Direction direction) {
@@ -303,7 +337,7 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
        public PipeControlPoint parent;
        public List<PipeControlPoint> children = new ArrayList<PipeControlPoint>();
 
-       public List<PipeControlPoint> getSubPoint() {
+       public List<PipeControlPoint> getChildPoints() {
                return children;
        }
 
@@ -334,7 +368,7 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
                this.length = l;
                firePropertyChanged("length");
                if (isDualInline())
-                       getSubPoint().get(0).setLength(l);
+                   getDualSub().setLength(l);
        }
 
        @GetPropertyValue(name="Turn Angle",tabId="Debug",value="turnAngle")
@@ -577,7 +611,7 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
 
                PipeControlPoint offsetCP = null;
                if (isOffset()) {
-                       offsetCP = getSubPoint().get(0);
+                       offsetCP = getDualSub();
                }
                if (previousNext != null && previousNext == next) {
                        if (previous.isDualInline()) {
@@ -602,7 +636,7 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
                        }
 
                        if (next.isDualInline()) {
-                               next.getSubPoint().get(0).setPrevious(this);
+                               next.getDualSub().setPrevious(this);
                        }
                } else if (previousPrevious != null && previousPrevious == next) {
                        // control point were given in reverse order 
@@ -620,7 +654,7 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
                                offsetCP.setPrevious(next);
                        }
                        if (previous.isDualInline()) {
-                               previous.getSubPoint().get(0).setPrevious(this);
+                               previous.getDualSub().setPrevious(this);
                        }
                        this.setPrevious(next);
                        next.setNext(this);
@@ -652,7 +686,7 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
                                pcp.getParentPoint().setNext(this);
                        }
                        if (isDualInline()) {
-                               getSubPoint().get(0).setPrevious(this);
+                           getDualSub().setPrevious(this);
                        }
                } else {
                        // if direction is previous, user must have given sizechange
@@ -662,7 +696,7 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
                        // we must link pcp to newCP's OffsetPoint
                        PipeControlPoint nocp = null;
                        if (isDualInline()) {
-                               nocp = getSubPoint().get(0);
+                               nocp = getDualSub();
                                nocp.setNext(pcp);
                        }
                        if (nocp == null) {
@@ -672,7 +706,7 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
                        }
                        this.setNext(pcp);
                        if (pcp.isDualInline()) {
-                               PipeControlPoint ocp = pcp.getSubPoint().get(0);
+                               PipeControlPoint ocp = pcp.getDualSub();
                                if (nocp == null)
                                        ocp.setPrevious(this);
                                else
@@ -741,7 +775,7 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
                        if (next != null) {
                                PipeControlPoint pcp = this;
                                if (pcp.isDualInline()) {
-                                       pcp = pcp.getSubPoint().get(0);
+                                       pcp = pcp.getDualSub();
                                }
                                Vector3d v = new Vector3d();
                                v.sub(next.getWorldPosition(),pcp.getWorldPosition());
@@ -796,7 +830,7 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
                                        if (isInline()) {
                                                PipeControlPoint pcp = this;
                                                if (pcp.isDualInline()) {
-                                                       pcp = pcp.getSubPoint().get(0);
+                                                       pcp = pcp.getDualSub();
                                                }
                                                Vector3d v = new Vector3d();
                                                v.sub(pcp.getWorldPosition(),next.getWorldPosition());
@@ -821,7 +855,7 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
        public void getInlineControlPointEnds(Tuple3d p1, Tuple3d p2) {
                assert (isInline());
 
-               PipeControlPoint sub = isAxial() ? this : getSubPoint().get(0);
+               PipeControlPoint sub = isAxial() ? this : getDualSub();
                Vector3d pos = getWorldPosition(), pos2 = sub == this ? pos : sub.getWorldPosition();
                Vector3d dir = sub.getPathLegDirection(Direction.NEXT);
                
@@ -834,7 +868,7 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
        }
 
        public void getControlPointEnds(Tuple3d p1, Tuple3d p2) {
-               PipeControlPoint sub = isAxial() || isDirected() || isTurn() ? this : getSubPoint().get(0);
+               PipeControlPoint sub = isAxial() || isDirected() || isTurn() ? this : getChildPoints().get(0);
                Vector3d pos = getWorldPosition(), pos2 = sub == this ? pos : sub.getWorldPosition();
                
                Vector3d dir1 = getPathLegDirection(Direction.PREVIOUS);
@@ -855,7 +889,7 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
        }
 
        public void getEndDirections(Tuple3d v1, Tuple3d v2) {
-               PipeControlPoint sub = isAxial() ? this : getSubPoint().get(0);
+               PipeControlPoint sub = isAxial() ? this : getDualSub();
                
                Vector3d dir1 = getPathLegDirection(Direction.PREVIOUS);
                dir1.normalize();
@@ -1010,17 +1044,24 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
        public void _remove() {
            _remove(true);
        }
+       
+       
+       public PipeControlPoint getDualSub() {
+           if (isDualInline())
+               return getChildPoints().get(0);
+           else
+               throw new IllegalStateException("Current control point is not dual inline");
+       }
+       
 
        public void _remove(boolean renconnect) {
                if (component == null && next == null && previous == null)
                        return;
                if (DEBUG) System.out.println(this + " Remove " + renconnect);
-               if (isDualInline() || isDualSub()) {
-                       removeDualPoint();
-                       return;
-               }
+
                if (getParentPoint() != null) {
                    getParentPoint()._remove(renconnect);
+                   return;
                }
                PipeRun pipeRun = getPipeRun();
                if (pipeRun == null)
@@ -1044,37 +1085,41 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
                                boolean link = renconnect;
                                if (currentNext.isBranchEnd()) {
                                        link = false;
-                                       //                                      currentNext.setPrevious(null);
-                                       //                                      currentNext.setNext(null);
                                        currentNext.remove();
                                        currentNext = null;
                                        setNext(null);
                                }
                                if (currentPrev.isBranchEnd()) {
                                        link = false;
-                                       //                                      currentPrev.setPrevious(null);
-                                       //                                      currentPrev.setNext(null);
                                        currentPrev.remove();
                                        currentPrev = null;
                                        setPrevious(null);
                                }
-                               if (link && currentPrev.isDirected() && currentNext.isDirected()) {
-                                       link = false;
+                               if (link) {
+                                   if (currentPrev.isDirected() && currentNext.isDirected())
+                                       link = false;
+                                   else if (this.isDualInline()) {
+                                       link = false;
+                                   } else if (this.isDualSub()) {
+                                       throw new RuntimeException("_remove() is called for parent point, somehow got to child point. " + this);
+                                   }
                                }
                                if (currentNext == null) {
                                        // Nothing to do
                                } else if (currentNext.isDualInline()) {
                                        PipeControlPoint sccp = currentNext;
-                                       PipeControlPoint ocp = sccp.getSubPoint().get(0);
+                                       PipeControlPoint ocp = currentNext.getDualSub();
                                        if (ocp == null) {
                                                throw new RuntimeException("Removing PipeControlPoint " + this+ " structure damaged, no offset control point");
                                        }
                                        if (link) {
                                                sccp.setPrevious(currentPrev);
-                                               ocp.setPrevious(currentPrev);
+                                               //ocp.setPrevious(currentPrev);
+                                               assert(ocp.getPrevious() == currentPrev);
                                        } else {
                                                sccp.setPrevious(null);
-                                               ocp.setPrevious(null);
+                                               //ocp.setPrevious(null);
+                                               assert(ocp.getPrevious() == null);
                                        }
                                        setNext(null);
                                } else if (currentNext.isDualSub()) {
@@ -1086,6 +1131,16 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
                                                currentNext.setPrevious(null);
                                        }
                                        setNext(null);
+                               } else if (isDualInline()) {
+                                   if (currentNext.previous != getDualSub()) {
+                                       throw new RuntimeException("Removing PipeControlPoint "+ this+ " structure damaged");
+                                   }
+                                   if (link) {
+                        currentNext.setPrevious(currentPrev);
+                    } else {
+                        currentNext.setPrevious(null);
+                    }
+                    setNext(null);
                                } else {
                                        throw new RuntimeException("Removing PipeControlPoint "+ this+ " structure damaged");
                                }
@@ -1095,15 +1150,17 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
                                        throw new RuntimeException("Removing PipeControlPoint " + this + " structure damaged, previous control point is size change control point");
                                } else if (currentPrev.isDualSub()) {
                                        PipeControlPoint ocp = currentPrev;
-                                       PipeControlPoint sccp = ocp.getParentPoint();
+                                       PipeControlPoint sccp = currentPrev.getParentPoint();
                                        if (sccp == null)
                                                throw new RuntimeException("Removing PipeControlPoint " + this + " structure damaged, no size change control point");
                                        if (link) {
-                                               ocp.setNext(currentNext);
+                                               //ocp.setNext(currentNext);
                                                sccp.setNext(currentNext);
+                                               assert(ocp.getNext() == currentNext);
                                        } else {
-                                               ocp.setNext(null);
+                                               //ocp.setNext(null);
                                                sccp.setNext(null);
+                                               assert(ocp.getNext() == null);
                                        }
                                        setPrevious(null);
                                } else if (currentPrev.next == this) {
@@ -1137,36 +1194,42 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
                                } else {
                                        // FIXME : pipe run must be split into two parts, since the control point structure is no more continuous. 
                                }
-                       } else if (next != null) {
-                               if (next.isDualInline()) {
-                                       PipeControlPoint sccp = next;
-                                       PipeControlPoint ocp = sccp.getSubPoint().get(0);
+                       } else if (currentNext != null) {
+                               if (currentNext.isDualInline()) {
+                                       PipeControlPoint sccp = currentNext;
+                                       PipeControlPoint ocp = getDualSub();
                                        if (ocp == null) {
                                                throw new RuntimeException("Removing PipeControlPoint " + this+ " structure damaged, no offset control point");
                                        }
                                        sccp.setPrevious(null);
-                                       ocp.setPrevious(null);
-                               } else if (next.isDualSub()) {
+                                       assert(ocp.getPrevious() == null);
+                                       //ocp.setPrevious(null);
+                               } else if (currentNext.isDualSub()) {
                                        throw new RuntimeException("Removing PipeControlPoint " + this + " structure damaged, next control point is offset control point");
-                               } else if (next.previous == this) {
-                                       next.setPrevious(null);
+                               } else if (currentNext.previous == this) {
+                                   currentNext.setPrevious(null);
+                               }  else if (isDualInline()) {
+                    if (currentNext.previous != getDualSub()) {
+                        throw new RuntimeException("Removing PipeControlPoint "+ this+ " structure damaged");
+                    }
+                    currentNext.setPrevious(null);
                                } else {
                                        throw new RuntimeException("Removing PipeControlPoint "+ this+ " structure damaged");
                                }
                                setNext(null);
                        } else {  //(previous != null)
-                               if(previous.isDualInline()) {
+                               if(currentPrev.isDualInline()) {
                                        throw new RuntimeException("Removing PipeControlPoint " + this + " structure damaged, previous control point is size change control point");
-                               } else if (previous.isDualSub()) {
-                                       PipeControlPoint ocp = previous;
-                                       PipeControlPoint sccp = ocp.getParentPoint();
+                               } else if (currentPrev.isDualSub()) {
+                                       PipeControlPoint ocp = currentPrev;
+                                       PipeControlPoint sccp = currentPrev.getParentPoint();
                                        if (sccp == null) {
                                                throw new RuntimeException("Removing PipeControlPoint " + this + " structure damaged, no size change control point");
                                        }
-                                       ocp.setNext(null);
                                        sccp.setNext(null);
-                               } else if (previous.next == this) {
-                                       previous.setNext(null);
+                                       assert(ocp.getNext() == null);
+                               } else if (currentPrev.next == this) {
+                                   currentPrev.setNext(null);
                                } else {
                                        throw new RuntimeException("Removing PipeControlPoint "+ this+ " structure damaged");
                                }
@@ -1267,76 +1330,51 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
                if (getPipelineComponent() == null)
                    return true; // already removed
            if (getPipelineComponent().getType().equals("Plant3D.URIs.Builtin_BranchSplitComponent")) {
-               if (getSubPoint().get(0).getNext() == null && getSubPoint().get(0).getPrevious() == null) {
+               if (getChildPoints().get(0).getNext() == null && getChildPoints().get(0).getPrevious() == null) {
                        remove();
                        return true;
                }
            }
-            return false;
+           return checkRemove(getPipeRun());
            }
     }
 
-       private void checkRemove(PipeRun pipeRun) {
+       private boolean checkRemove(PipeRun pipeRun) {
                Collection<PipeControlPoint> points = pipeRun.getControlPoints();
                if (points.size() == 0) {
                        pipeRun.remove();
+                       return true;
                } else if (points.size() == 1) {
                        PipeControlPoint pcp = points.iterator().next();
-                       if (pcp.isDeletable())
-                               pcp._remove();
-               }
-       }
-
-       private void removeDualPoint() {
-               if (previous != null)
-                       previous.setNext(null);
-               if (next != null)
-                       next.setPrevious(null);
-               PipeControlPoint ocp;
-               PipeControlPoint sccp;
-               if (isDualInline()) {
-                       sccp = this;
-                       ocp = getSubPoint().get(0);
-               } else {
-                       ocp = this;
-                       sccp = getParentPoint();
+                       if (pcp.isDeletable() && pcp.getNext() == null && pcp.getPrevious() == null) {
+                               pcp._remove(); // This call will recursively call also this method...
+                               return true;
+                       }
                }
-               PipeRun p1 = ocp.getPipeRun();
-               PipeRun p2 = sccp.getPipeRun();
-
-               ocp.removeComponent();
-               sccp.removeComponent();
-
-               if (p1 != null)
-                       p1.remChild(ocp);
-               if (p2 != null)
-                       p2.remChild(sccp);
-
-               // TODO : now we assume that this is size change, and we do
-               if (ocp.next != null)
-                       ocp.next.setPrevious(null);
-               if (ocp.previous != null)
-                       ocp.previous.setNext(null);
-               if (sccp.next != null)
-                       sccp.next.setPrevious(null);
-               if (sccp.previous != null)
-                       sccp.previous.setNext(null);
-               ocp.setNext(null);
-               ocp.setPrevious(null);
-               sccp.setNext(null);
-               sccp.setPrevious(null);
-
-               if (p1 != null)
-                       checkRemove(p1);
-               if (p2 != null)
-                       checkRemove(p2);
+               return false;
        }
 
        private void removeSubPoints() {
                for (PipeControlPoint p : children) {
-                       // TODO : this may affect delete routine, since classification of the point changes.
                        p.parent = null;
-                       p._remove();
+                       p.component = null;
+                       //p._remove();
+                       PipeControlPoint currentNext = p.getNext();
+                       PipeControlPoint currentPrev = p.getPrevious();
+                       p._setNext(null);
+                       p._setPrevious(null);
+                       PipeRun run = p.getPipeRun();
+                       if (run != null) {
+                           run.remChild(p);
+                           checkRemove(run);
+                       }
+                       if (currentNext != null)
+                if (!currentNext.checkRemove())
+                    PipingRules.requestUpdate(currentNext);
+            if (currentPrev != null)
+                if (!currentPrev.checkRemove())
+                    PipingRules.requestUpdate(currentPrev);
+            
                }
                children.clear();
        }
@@ -1413,20 +1451,20 @@ public class PipeControlPoint extends G3DNode implements IP3DNode {
        private void updateSubPoint() {
                if (isOffset()) {
                        if (next == null && previous == null) {
-                               for (PipeControlPoint sub : getSubPoint()) {
+                               for (PipeControlPoint sub : getChildPoints()) {
                                        sub.setWorldPosition(getWorldPosition());
                                        sub.setWorldOrientation(getWorldOrientation());
                                }
                                return;
                        }
-                       for (PipeControlPoint sub : getSubPoint()) {
+                       for (PipeControlPoint sub : getChildPoints()) {
                                Vector3d wp = getWorldPosition();
                                wp.add(getSizeChangeOffsetVector());
                                sub.setWorldPosition(wp);
                                sub.setWorldOrientation(getWorldOrientation());
                        }
                } else {
-                       for (PipeControlPoint sub : getSubPoint()) {
+                       for (PipeControlPoint sub : getChildPoints()) {
                                sub.setWorldPosition(getWorldPosition());
                                sub.setWorldOrientation(getWorldOrientation());
                        }

diff --git a/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/controlpoint/PipingRules.java b/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/controlpoint/PipingRules.java
index f5c6f876a98d507eca60c31bcd809dd8f25bb37d..de96517552f7d6774f7c0ef0cf20c04820e17f93 100644 (file)
--- a/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/controlpoint/PipingRules.java
+++ b/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/controlpoint/PipingRules.java
@@ -218,15 +218,15 @@ public class PipingRules {
                        System.out.println("PipingRules.insertElbow() " + pcp1 + " " + pcp2 + " " + pos);
                if (pcp1.getNext() == pcp2 && pcp2.getPrevious() == pcp1) {
                        
-               } else if (pcp1.getNext() == pcp2 && pcp1.isDualInline() && pcp2.getPrevious() == pcp1.getSubPoint().get(0)) {
-                       pcp1 = pcp1.getSubPoint().get(0);       
+               } else if (pcp1.getNext() == pcp2 && pcp1.isDualInline() && pcp2.getPrevious() == pcp1.getDualSub()) {
+                       pcp1 = pcp1.getDualSub();       
                } else if (pcp1.getPrevious() == pcp2 && pcp2.getNext() == pcp1) {
                        PipeControlPoint t = pcp1;
                        pcp1 = pcp2;
                        pcp2 = t;
-               } else if (pcp2.isDualInline() && pcp1.getPrevious() == pcp2.getSubPoint().get(0) && pcp2.getNext() == pcp1) {
+               } else if (pcp2.isDualInline() && pcp1.getPrevious() == pcp2.getDualSub() && pcp2.getNext() == pcp1) {
                        PipeControlPoint t = pcp1;
-                       pcp1 = pcp2.getSubPoint().get(0);
+                       pcp1 = pcp2.getDualSub();
                        pcp2 = t;
                } else {
                        throw new RuntimeException();
@@ -234,7 +234,7 @@ public class PipingRules {
                TurnComponent elbow = ComponentUtils.createTurn((P3DRootNode)pcp1.getRootNode());
                PipeControlPoint pcp = elbow.getControlPoint();
                if (pcp1.isDualInline())
-                       pcp1 = pcp1.getSubPoint().get(0);
+                       pcp1 = pcp1.getDualSub();
                String name = pcp1.getPipeRun().getUniqueName("Elbow");
                elbow.setName(name);
                pcp1.getPipeRun().addChild(elbow);
@@ -251,15 +251,15 @@ public class PipingRules {
                        System.out.println("PipingRules.insertStraight() " + pcp1 + " " + pcp2 + " " + pos);
                if (pcp1.getNext() == pcp2 && pcp2.getPrevious() == pcp1) {
                        
-               } else if (pcp1.getNext() == pcp2 && pcp1.isDualInline() && pcp2.getPrevious() == pcp1.getSubPoint().get(0)) {
-                       pcp1 = pcp1.getSubPoint().get(0);       
+               } else if (pcp1.getNext() == pcp2 && pcp1.isDualInline() && pcp2.getPrevious() == pcp1.getDualSub()) {
+                       pcp1 = pcp1.getDualSub();       
                } else if (pcp1.getPrevious() == pcp2 && pcp2.getNext() == pcp1) {
                        PipeControlPoint t = pcp1;
                        pcp1 = pcp2;
                        pcp2 = t;
-               } else if (pcp2.isDualInline() && pcp1.getPrevious() == pcp2.getSubPoint().get(0) && pcp2.getNext() == pcp1) {
+               } else if (pcp2.isDualInline() && pcp1.getPrevious() == pcp2.getDualSub() && pcp2.getNext() == pcp1) {
                        PipeControlPoint t = pcp1;
-                       pcp1 = pcp2.getSubPoint().get(0);
+                       pcp1 = pcp2.getDualSub();
                        pcp2 = t;
                } else {
                        throw new RuntimeException();
@@ -267,7 +267,7 @@ public class PipingRules {
                InlineComponent component = ComponentUtils.createStraight((P3DRootNode)pcp1.getRootNode());
                PipeControlPoint scp = component.getControlPoint();
                if (pcp1.isDualInline())
-                       pcp1 = pcp1.getSubPoint().get(0);
+                       pcp1 = pcp1.getDualSub();
                String name = pcp1.getPipeRun().getUniqueName("Pipe");
                component.setName(name);
                pcp1.getPipeRun().addChild(component);
@@ -287,7 +287,7 @@ public class PipingRules {
                InlineComponent component = ComponentUtils.createStraight((P3DRootNode)pcp.getRootNode());
                PipeControlPoint scp = component.getControlPoint();
                if (pcp.isDualInline() && direction == Direction.NEXT)
-                       pcp = pcp.getSubPoint().get(0);
+                       pcp = pcp.getDualSub();
                String name = pcp.getPipeRun().getUniqueName("Pipe");
                component.setName(name);
                pcp.getPipeRun().addChild(component);
@@ -610,7 +610,7 @@ public class PipingRules {
                                PipeControlPoint next = i < pathLegPoints.size() - 1 ? pathLegPoints.get(i + 1) : null;
                                
                                if (prev != null && prev.isDualInline())
-                                       prev = prev.getSubPoint().get(0);
+                                       prev = prev.getDualSub();
                                
 
                                if (icp.isVariableLength()) {
@@ -1394,7 +1394,7 @@ public class PipingRules {
        private static void updateOffsetPoint(PipeControlPoint sccp, Vector3d offset) {
                Vector3d world = sccp.getWorldPosition();
                world.add(offset);
-               PipeControlPoint ocp = sccp.getSubPoint().iterator().next();
+               PipeControlPoint ocp = sccp.getDualSub();
                ocp.setWorldPosition(world);
        }
 
@@ -1430,7 +1430,7 @@ public class PipingRules {
                if (canCalc) {
                        boolean branchUpdate = false;
                        PipeControlPoint becp = null;
-                       for (PipeControlPoint pcp : icp.getSubPoint())
+                       for (PipeControlPoint pcp : icp.getChildPoints())
                                if (pcp.isNonDirected()) {
                                        branchUpdate = true;
                                        becp = pcp;
@@ -1497,7 +1497,7 @@ public class PipingRules {
                //if (!ecp.isFixed())
                updateControlPointOrientation(ecp);
 
-               for (PipeControlPoint pcp : ecp.getSubPoint()) {
+               for (PipeControlPoint pcp : ecp.getChildPoints()) {
                        // TODO update position
                        updatePathLegEndControlPoint(pcp);
                }
@@ -1531,7 +1531,7 @@ public class PipingRules {
                        System.out.println("PipingRules.updateBranchControlPointBranches() " + bcp);
                if (bcp.isDualInline())
                        return;
-               Collection<PipeControlPoint> branches = bcp.getSubPoint();
+               Collection<PipeControlPoint> branches = bcp.getChildPoints();
                if (branches.size() == 0) {
                        if (DEBUG)
                                System.out.println("No Branches found");
@@ -1657,7 +1657,7 @@ public class PipingRules {
                while (true) {
                        List<PipeControlPoint> points = getControlPoints(pipeRun);
                        PipeControlPoint pcp = points.get(0);
-                       if (pcp.isSizeChange() && pcp.getSubPoint().size() > 0) {
+                       if (pcp.isSizeChange() && pcp.getChildPoints().size() > 0) {
                                pipeRun = pcp.getPipeRun();
                        } else {
                                break;
@@ -1670,8 +1670,8 @@ public class PipingRules {
                        List<PipeControlPoint> points = getControlPoints(pipeRun);
                        pcps.add(points);
                        PipeControlPoint pcp = points.get(points.size()-1);
-                       if (pcp.getSubPoint().size() > 0) {
-                               pipeRun = pcp.getSubPoint().get(0).getPipeRun();
+                       if (pcp.getChildPoints().size() > 0) {
+                               pipeRun = pcp.getChildPoints().get(0).getPipeRun();
                        } else {
                                break;
                        }
@@ -1719,11 +1719,11 @@ public class PipingRules {
                        PipeControlPoint current = list.get(i);
                        PipeControlPoint currentSub = null;
                        if (current.isDualInline())
-                               currentSub = current.getSubPoint().get(0);
+                               currentSub = current.getDualSub();
                        if (first) {
                                PipeControlPoint next = list.get(i+1);
                                if (next.isDualInline())
-                                       next = next.getSubPoint().get(0);
+                                       next = next.getDualSub();
                                if (current.getNext() == next)
                                        current.setNext(null);
                                current.setPrevious(next);
@@ -1748,7 +1748,7 @@ public class PipingRules {
                                PipeControlPoint prev = list.get(i-1);
                                PipeControlPoint next = list.get(i+1);
                                if (next.isDualInline())
-                                       next = next.getSubPoint().get(0);
+                                       next = next.getDualSub();
                                
                                
                                current.setPrevious(next);
@@ -1825,7 +1825,7 @@ public class PipingRules {
                        if (pcp.getParentPoint() == null) {
                                PipeControlPoint sub = null;
                                if (pcp.isDualInline())
-                                       sub = pcp.getSubPoint().get(0);
+                                       sub = pcp.getDualSub();
                                PipeControlPoint next = pcp.getNext();
                                PipeControlPoint prev = pcp.getPrevious();
                                if (next != null) {
@@ -1936,7 +1936,7 @@ public class PipingRules {
        
        public static void addSizeChange(boolean reversed, PipeRun pipeRun, PipeRun other, InlineComponent reducer, PipeControlPoint previous, PipeControlPoint next) {
                PipeControlPoint pcp = reducer.getControlPoint();
-               PipeControlPoint ocp = pcp.getSubPoint().get(0);
+               PipeControlPoint ocp = pcp.getDualSub();
                if (!reversed) {
                        String name = pipeRun.getUniqueName("Reducer");
                        reducer.setName(name);

diff --git a/org.simantics.plant3d/src/org/simantics/plant3d/utils/ComponentUtils.java b/org.simantics.plant3d/src/org/simantics/plant3d/utils/ComponentUtils.java
index 4e3571444ae3bf759436fe01054330cf586b197b..69bf593156e3fa448e8a335e94de60388712c54c 100644 (file)
--- a/org.simantics.plant3d/src/org/simantics/plant3d/utils/ComponentUtils.java
+++ b/org.simantics.plant3d/src/org/simantics/plant3d/utils/ComponentUtils.java
@@ -344,7 +344,7 @@ public class ComponentUtils {
                        switch (position) {
                        case NEXT: 
                                if (toPcp.isDualInline()) {
-                                       toPcp = toPcp.getSubPoint().get(0);
+                                       toPcp = toPcp.getDualSub();
                                        pipeRun = toPcp.getPipeRun();
                                }
                                
@@ -443,7 +443,7 @@ public class ComponentUtils {
                        switch (position) {
                        case NEXT: 
                                if (toPcp.isDualInline())
-                                       toPcp = toPcp.getSubPoint().get(0);
+                                       toPcp = toPcp.getDualSub();
                                newPcp.insert(toPcp, Direction.NEXT);
                                newPcp.setWorldPosition(pos);
                                break;