Allow insertion of reducers in the middle of pipe runs

[simantics/3d.git] / org.simantics.plant3d / src / org / simantics / plant3d / utils / ComponentUtils.java

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 0ae36e33a2f51ca7a3aa549c14244f4547c873c9..5a84a5244839cd2b94f1660312005b68273bc2f9 100644 (file)
--- a/org.simantics.plant3d/src/org/simantics/plant3d/utils/ComponentUtils.java
+++ b/org.simantics.plant3d/src/org/simantics/plant3d/utils/ComponentUtils.java
@@ -436,77 +436,79 @@ public class ComponentUtils {
                        }
                }
                
-               
-               if (!sizeChange) {
-                       String name = component.getPipeRun().getUniqueName(typeName);
-                       newComponent.setName(name);
+               String name = component.getPipeRun().getUniqueName(typeName);
+               newComponent.setName(name);
 
-                       pipeRun.addChild(newComponent);
+               pipeRun.addChild(newComponent);
+               if (newPcp.isSizeChange())
+                       newComponent.setAlternativePipeRun(pipeRun);
 
-                       if (newComponent instanceof InlineComponent) {
-                           InlineComponent inlineComponent = (InlineComponent)newComponent;
-                           if (inlineComponent.isVariableLength()|| inlineComponent.isModifialble()) {
-                               newPcp.setLength(inst.length);
-                               newComponent.setParameter("length", inst.length);
-                           }
-                           if (inst.rotationAngle != null)
-                               ((InlineComponent) newComponent).setRotationAngle(inst.rotationAngle);
-                       } else if (newComponent instanceof TurnComponent) {
-                           TurnComponent turnComponent = (TurnComponent)newComponent;
-                           if  (turnComponent.isVariableAngle()) {
-                               newPcp.setTurnAngle(inst.angle);
-                               newComponent.setParameter("turnAngle", inst.angle);
-                           }
-                           if (inst.rotationAngle != null)
-                       ((TurnComponent) newComponent).setRotationAngle(inst.rotationAngle);
-                       }
-                       
-                       
-                       newComponent.updateParameters();
-                       
-                       Vector3d v = new Vector3d(dir);
-                       if (insertAdjustable) {
-                               if (insertPosition == PositionType.NEXT)
-                                       v.scale(newComponent.getControlPoint().getInlineLength());
-                               else if (insertPosition == PositionType.SPLIT)
-                                       v.set(0, 0, 0);
-                               else if (insertPosition == PositionType.PREVIOUS)
-                                       v.scale(-newComponent.getControlPoint().getInlineLength());
-                       } else {
+               if (newComponent instanceof InlineComponent) {
+                   InlineComponent inlineComponent = (InlineComponent)newComponent;
+                   if (inlineComponent.isVariableLength()|| inlineComponent.isModifialble()) {
+                       newPcp.setLength(inst.length);
+                       newComponent.setParameter("length", inst.length);
+                   }
+                   if (inst.rotationAngle != null)
+                       ((InlineComponent) newComponent).setRotationAngle(inst.rotationAngle);
+               } else if (newComponent instanceof TurnComponent) {
+                   TurnComponent turnComponent = (TurnComponent)newComponent;
+                   if  (turnComponent.isVariableAngle()) {
+                               newPcp.setTurnAngle(inst.angle);
+                               newComponent.setParameter("turnAngle", inst.angle);
+                   }
+                   if (inst.rotationAngle != null)
+                ((TurnComponent) newComponent).setRotationAngle(inst.rotationAngle);
+               }
+               
+               
+               newComponent.updateParameters();
+               
+               Vector3d v = new Vector3d(dir);
+               if (insertAdjustable) {
+                       if (insertPosition == PositionType.NEXT)
                                v.scale(newComponent.getControlPoint().getInlineLength());
-                       }
-                       switch (position) {
-                       case NEXT:
-                               pos.add(v);
-                               break;
-                       case PREVIOUS:
-                               pos.sub(v);
-                               break;
-                       case SPLIT:
-                               break;
-                       default:
-                               break;
-                       }
-                       
-                       switch (position) {
-                       case NEXT: 
-                               if (toPcp.isDualInline())
-                                       toPcp = toPcp.getDualSub();
-                               newPcp.insert(toPcp, Direction.NEXT);
-                               newPcp.setWorldPosition(pos);
-                               break;
-                       case PREVIOUS:
-                               if (toPcp.isDualSub())
-                                       toPcp = toPcp.parent;
-                               newPcp.insert(toPcp, Direction.PREVIOUS);
-                               newPcp.setWorldPosition(pos);
-                               break;
-                       case SPLIT:
-                               PipingRules.splitVariableLengthComponent(newComponent, (InlineComponent)component, true);
-                       default:
-                               break;
-                       }
+                       else if (insertPosition == PositionType.SPLIT)
+                               v.set(0, 0, 0);
+                       else if (insertPosition == PositionType.PREVIOUS)
+                               v.scale(-newComponent.getControlPoint().getInlineLength());
                } else {
+                       v.scale(newComponent.getControlPoint().getInlineLength());
+               }
+               switch (position) {
+               case NEXT:
+                       pos.add(v);
+                       break;
+               case PREVIOUS:
+                       pos.sub(v);
+                       break;
+               case SPLIT:
+                       break;
+               default:
+                       break;
+               }
+               
+               switch (position) {
+               case NEXT: 
+                       if (toPcp.isDualInline())
+                               toPcp = toPcp.getDualSub();
+                       newPcp.insert(toPcp, Direction.NEXT);
+                       newPcp.setWorldPosition(pos);
+                       break;
+               case PREVIOUS:
+                       if (toPcp.isDualSub())
+                               toPcp = toPcp.parent;
+                       newPcp.insert(toPcp, Direction.PREVIOUS);
+                       newPcp.setWorldPosition(pos);
+                       break;
+               case SPLIT:
+                       PipingRules.splitVariableLengthComponent(newComponent, (InlineComponent)component, true);
+               default:
+                       break;
+               }
+               
+               // Move the size change and the rest of the components in the pipe run to a new pipe run
+               if (sizeChange) {
                        PipeRun other = new PipeRun();
                        String n = root.getUniqueName("PipeRun");
                        other.setName(n);
@@ -514,39 +516,31 @@ public class ComponentUtils {
                        other.setTurnRadius(inst.turnRadius);
                        root.addChild(other);
                        
+                       other.addChild(newComponent.getControlPoint().getDualSub());
+                       newComponent.setAlternativePipeRun(other);
                        
-                       if (position == PositionType.NEXT) {
-                               PipingRules.addSizeChange(false, pipeRun, other, (InlineComponent)newComponent, toPcp, null);
-                       } else if (position == PositionType.PREVIOUS){
-                               PipingRules.addSizeChange(true, pipeRun, other, (InlineComponent)newComponent, toPcp, null);
-                       }
-                       newPcp.setWorldPosition(pos);
-
-                       // TODO : chicken-egg problem
-                       newComponent.updateParameters();
-                       Vector3d v = new Vector3d(dir);
-                       v.scale(newComponent.getControlPoint().getLength()*0.5);
-                       switch (position) {
-                       case NEXT:
-                               pos.add(v);
-                               break;
-                       case PREVIOUS:
-                               pos.sub(v);
-                               break;
-                       case SPLIT:
-                               break;
-                       default:
-                               break;
+                       boolean forward = position != PositionType.PREVIOUS;
+                       PipelineComponent comp = forward ? newComponent.getNext() : newComponent.getPrevious();
+                       while (comp != null && comp.getPipeRun() == pipeRun) {
+                               if (comp.getParent() == pipeRun) {
+                                       comp.deattach();
+                                       other.addChild(comp);
+                               } else {
+                                       comp.setPipeRun(other);
+                               }
+                               
+                               // Reset parameters to match new pipe run
+                               comp.updateParameters();
+                               
+                               comp = forward ? comp.getNext() : comp.getPrevious();
                        }
-                       newPcp.setWorldPosition(pos);
-               if (inst.rotationAngle != null)
-                  ((InlineComponent) newComponent).setRotationAngle(inst.rotationAngle);
                        
+                       newComponent.updateParameters();
                }
-                               
                
                return newComponent;
        }
+       
        public static boolean connect(PipelineComponent current, PipelineComponent endTo) throws Exception {
                return connect(current, endTo, null, null);
        }