PipeCOntrolPoint setNext/setPrev/remove improved

[simantics/3d.git] / org.simantics.plant3d / src / org / simantics / plant3d / scenegraph / controlpoint / PipingRules.java

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 eb07e9c0f86c5d1340eabc5da22931f12bfe893f..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);
@@ -375,6 +375,7 @@ public class PipingRules {
 
        }
 
+       @SuppressWarnings("unused")
        private static boolean calculateOffset(Vector3d startPoint, Vector3d endPoint, ArrayList<PipeControlPoint> list, Vector3d dir, Vector3d offset) {
                boolean hasOffsets = false;
                List<PipeControlPoint> offsets = new ArrayList<PipeControlPoint>(list.size());
@@ -609,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()) {
@@ -718,7 +719,7 @@ public class PipingRules {
                                                                                                        // position of the
                                                                                                        // component
                                dir.add(prevPos);
-                               PipeControlPoint scp = insertStraight(prev, icp, dir, length);
+                               insertStraight(prev, icp, dir, length);
                                return true;
                        } else {
                                triedIR = true;
@@ -1372,6 +1373,7 @@ public class PipingRules {
        // end,Point3d endPoint, Vector3d dir, boolean hasOffsets,int iter, boolean
        // reversed, ArrayList<ExpandIterInfo> toRemove) throws TransactionException
        // {
+       @SuppressWarnings("unused")
        private static void processPathLegNoOffset(UpdateStruct2 u) throws Exception {
                if (DEBUG)
                        System.out.println("PipingRules.processPathLeg " + u.start + " " + u.end);
@@ -1392,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);
        }
 
@@ -1428,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;
@@ -1495,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);
                }
@@ -1529,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");
@@ -1655,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;
@@ -1668,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;
                        }
@@ -1717,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);
@@ -1746,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);
@@ -1823,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) {
@@ -1876,7 +1878,6 @@ public class PipingRules {
                        // this should not be possible
                        throw new RuntimeException("VariableLengthComponent " + splittingComponent + " is not connected to anything.");
                }
-               double reservedLength = splittingComponent.getControlPoint().getLength();
                double newLength = newComponent.getControlPoint().getLength();
                
                
@@ -1912,21 +1913,20 @@ public class PipingRules {
                vn.interpolate(next, 0.5);
                
                
-               PipeControlPoint newVariableLengthCP = null;//insertStraight(pcp1, pcp2, pos, length);
                if (nextCP == null) {
                        newCP.insert(splittingCP, Direction.NEXT);
-                       newVariableLengthCP = insertStraight(newCP, Direction.NEXT, new Vector3d(vn), ln);
+                       insertStraight(newCP, Direction.NEXT, new Vector3d(vn), ln);
                        splittingCP.setWorldPosition(new Vector3d(vp));
 //                     ControlPointTools.setWorldPosition(splittingCP, vp);
 //                     splittingCP.setRelatedScalarDouble(ProcessResource.plant3Dresource.HasLength, lp);
                } else if (prevCP == null) {
                        newCP.insert(splittingCP, Direction.PREVIOUS);
-                       newVariableLengthCP = insertStraight(newCP, Direction.PREVIOUS, new Vector3d(vp), lp);
+                       insertStraight(newCP, Direction.PREVIOUS, new Vector3d(vp), lp);
                        splittingCP.setWorldPosition(new Vector3d(vn));
 //                     splittingCP.setRelatedScalarDouble(ProcessResource.plant3Dresource.HasLength, ln);
                } else {
                        newCP.insert(splittingCP, nextCP);
-                       newVariableLengthCP = insertStraight(newCP, nextCP, new Vector3d(vn), ln);
+                       insertStraight(newCP, nextCP, new Vector3d(vn), ln);
                        splittingCP.setWorldPosition(new Vector3d(vp));
 //                     splittingCP.setRelatedScalarDouble(ProcessResource.plant3Dresource.HasLength, lp);
                }
@@ -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);