]> gerrit.simantics Code Review - simantics/3d.git/blob - org.simantics.plant3d/src/org/simantics/plant3d/actions/RoutePipeAction.java
Missing library URI from Equipment selection dialog parameters.
[simantics/3d.git] / org.simantics.plant3d / src / org / simantics / plant3d / actions / RoutePipeAction.java
1 package org.simantics.plant3d.actions;
2
3 import java.awt.event.KeyEvent;
4 import java.awt.event.MouseEvent;
5 import java.awt.event.MouseWheelEvent;
6 import java.math.BigDecimal;
7 import java.util.ArrayList;
8 import java.util.HashSet;
9 import java.util.List;
10 import java.util.Set;
11
12 import javax.vecmath.Point3d;
13 import javax.vecmath.Tuple3d;
14 import javax.vecmath.Vector3d;
15
16 import org.eclipse.swt.SWT;
17 import org.eclipse.swt.events.SelectionAdapter;
18 import org.eclipse.swt.events.SelectionEvent;
19 import org.eclipse.swt.widgets.Button;
20 import org.eclipse.swt.widgets.Combo;
21 import org.eclipse.swt.widgets.Label;
22 import org.simantics.db.Resource;
23 import org.simantics.g3d.math.MathTools;
24 import org.simantics.g3d.math.Ray;
25 import org.simantics.g3d.scenegraph.NodeMap;
26 import org.simantics.g3d.scenegraph.base.INode;
27 import org.simantics.g3d.toolbar.ToolComposite;
28 import org.simantics.g3d.tools.ConstraintDetector;
29 import org.simantics.g3d.vtk.gizmo.TranslateAxisGizmo;
30 import org.simantics.g3d.vtk.swt.InteractiveVtkComposite;
31 import org.simantics.g3d.vtk.swt.vtkSwtAction;
32 import org.simantics.g3d.vtk.utils.vtkUtil;
33 import org.simantics.plant3d.Activator;
34 import org.simantics.plant3d.gizmo.ConstraintPointGizmo;
35 import org.simantics.plant3d.gizmo.SplitPointSelectionGizmo;
36 import org.simantics.plant3d.gizmo.TerminalSelectionGizmo;
37 import org.simantics.plant3d.scenegraph.EndComponent;
38 import org.simantics.plant3d.scenegraph.InlineComponent;
39 import org.simantics.plant3d.scenegraph.Nozzle;
40 import org.simantics.plant3d.scenegraph.P3DRootNode;
41 import org.simantics.plant3d.scenegraph.PipeRun;
42 import org.simantics.plant3d.scenegraph.PipelineComponent;
43 import org.simantics.plant3d.scenegraph.TurnComponent;
44 import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint;
45 import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint.Direction;
46 import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint.PositionType;
47 import org.simantics.plant3d.scenegraph.controlpoint.PipingRules;
48 import org.simantics.plant3d.utils.ComponentUtils;
49 import org.simantics.utils.threads.ThreadUtils;
50 import org.simantics.utils.ui.ExceptionUtils;
51
52 import vtk.vtkProp;
53 import vtk.vtkTextActor;
54
55 public class RoutePipeAction extends vtkSwtAction {
56         enum LockType {
57                 X, Y, Z, XY, XZ, YZ, NONE, CUSTOM
58         };
59
60         LockType lock = LockType.NONE;
61         boolean lockForced;
62         private double BRANCH_SNAP_DISTANCE = 0.05;
63         private double NOZZLE_SNAP_DISTANCE = 0.05;
64         private static double BRANCH_DOT_PRODUCT = 0.95; // dot product value used for prevent branch creation
65         private static double ALIGN_DOT_PRODUCT = 0.99; // dot product for creating turn when connecting pipes
66
67         private double istep = 10.0;
68         private int decimals = 2;
69
70         private P3DRootNode root;
71         protected PipelineComponent startComponent;
72         protected PipeRun pipeRun;
73         private boolean allowBranches;
74
75         protected TranslateAxisGizmo translateAxisGizmo = new TranslateAxisGizmo();
76         private SplitPointSelectionGizmo splitPointSelectionGizmo;
77         private ConstraintPointGizmo constraintPointGizmo;
78         private TerminalSelectionGizmo terminalSelectionGizmo;
79         private NodeMap<Resource,vtkProp,INode> nodeMap;
80         
81         protected enum ToolState{NOT_ACTIVE, INITIALIZING, SELECTING_POSITION, SELECTING_SPLIT, ROUTING};
82         protected ToolState state = ToolState.NOT_ACTIVE;
83         
84         private ConstraintDetector detector;// = new DummyConstraintDetector();
85         
86         protected boolean useDefault = false;
87         protected Vector3d direction = null;
88         protected Vector3d previousPosition = null;
89         protected Vector3d currentPosition = null;
90         
91         boolean step = false;
92         
93         PipelineComponent endTo = null;
94         PositionType endType = null;
95         PipeControlPoint endPort = null;
96         
97         boolean reversed = false;
98         
99         private Set<PositionType> allowed = new HashSet<PositionType>();
100         
101         protected ToolComposite toolComposite;
102     protected Combo axisCombo;
103     protected Button cameraButton;
104         
105         public RoutePipeAction(InteractiveVtkComposite panel, P3DRootNode root, ToolComposite toolComposite) {
106             this(panel,root, toolComposite, true);
107         }
108         
109         public RoutePipeAction(InteractiveVtkComposite panel, P3DRootNode root, ToolComposite toolComposite, boolean allowBranches) {
110                 super(panel);
111                 this.root = root;
112                 this.allowBranches = allowBranches;
113                 setText("Route Pipe");
114                 setImageDescriptor(Activator.imageDescriptorFromPlugin(Activator.PLUGIN_ID, "icons/Straight.png"));
115                 nodeMap = root.getNodeMap();
116                 splitPointSelectionGizmo = new SplitPointSelectionGizmo(panel);
117                 terminalSelectionGizmo = new TerminalSelectionGizmo(panel);
118                 constraintPointGizmo = new ConstraintPointGizmo(panel);
119                 detector = new org.simantics.g3d.vtk.swt.ConstraintDetector(panel);
120                 this.toolComposite = toolComposite;
121         }
122         
123         public void setComponent(PipelineComponent component) {
124                 this.startComponent = component;
125                 allowed.clear();
126                 if (this.startComponent.getNext() == null)
127                         allowed.add(PositionType.NEXT);
128                 if (this.startComponent.getPrevious() == null && !(this.startComponent instanceof Nozzle))
129                         allowed.add(PositionType.PREVIOUS);
130                 if (allowBranches && this.startComponent instanceof InlineComponent && !this.startComponent.getControlPoint().isFixedLength())
131                         allowed.add(PositionType.SPLIT);
132                 setEnabled(allowed.size() > 0);
133         }
134         
135         protected void createTools(ToolComposite toolComposite) {
136         Label label = new Label(toolComposite, SWT.READ_ONLY);
137         label.setText("Route direction:");
138         axisCombo = new Combo(toolComposite, SWT.READ_ONLY);
139         axisCombo.add("X");
140         axisCombo.add("Y");
141         axisCombo.add("Z");
142         axisCombo.add("XY");
143         axisCombo.add("XZ");
144         axisCombo.add("YZ");
145         axisCombo.add("None");
146         axisCombo.add("Custom");
147         axisCombo.addSelectionListener(new SelectionAdapter() {
148             @Override
149             public void widgetSelected(SelectionEvent e) {
150                 Combo c = (Combo)e.getSource();
151                 setLockType(LockType.values()[c.getSelectionIndex()],false);
152                 panel.getComponent().setFocus();
153                 
154             }
155         });
156         axisCombo.select(lock.ordinal());
157         cameraButton = new Button(toolComposite, SWT.TOGGLE);
158         cameraButton.setText("Camera");
159         cameraButton.setSelection(useDefault);
160         cameraButton.addSelectionListener(new SelectionAdapter() {
161             @Override
162             public void widgetSelected(SelectionEvent e) {
163                 setUseDefault(((Button)e.getSource()).getSelection());
164                 panel.getComponent().setFocus();
165             }
166         });
167         Button close = new Button(toolComposite, SWT.PUSH);
168         close.setText("Close");
169         close.addSelectionListener(new SelectionAdapter() {
170             public void widgetSelected(SelectionEvent e) {
171                 panel.useDefaultAction();
172             };
173         });
174         toolComposite.relayout();
175     }
176
177     public void deattach() {
178         deactivate();
179         if (toolComposite != null) {
180             toolComposite.clear();
181             axisCombo = null;
182             cameraButton = null;
183         }
184
185         startComponent = null;
186
187         deattachUI();
188         super.deattach();
189         panel.refresh();
190     }
191         
192         public void attach() {
193                 if (startComponent == null)
194                         return;
195                 if (toolComposite != null) {
196                    createTools(toolComposite); 
197             }
198                 super.attach();
199                 ThreadUtils.asyncExec(panel.getThreadQueue(), new Runnable() {
200                         public void run() {
201 //                              attachUI();
202                                 try {
203                                         activate();
204                                 } catch (Exception e) {
205                                         deattach();
206                                         ExceptionUtils.logAndShowError(e);
207                                 }
208                                 
209                         }
210                 });
211                 
212         }
213         
214 //      private void attachUI() {
215 //              //panel.setCursor(activeCursor);
216 //              translateAxisGizmo.attach(panel.GetRenderer());
217 //      }
218         
219         private void deattachUI() {
220                 //panel.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
221                 panel.lock();
222                 if (translateAxisGizmo.isAttached())
223                         translateAxisGizmo.deattach();
224                 if (splitPointSelectionGizmo.isAttached())
225                         splitPointSelectionGizmo.deattach();
226                 if (terminalSelectionGizmo.isAttached())
227                         terminalSelectionGizmo.deattach();
228                 if (constraintPointGizmo.isAttached())
229                     constraintPointGizmo.deattach();
230                 if (infoActor != null) {
231                         panel.getRenderer().RemoveActor(infoActor);
232                         infoActor.Delete();
233                         infoActor = null;
234                 }
235                 panel.unlock();
236         }
237         
238         protected List<PipelineComponent> added = new ArrayList<PipelineComponent>();
239         
240         @Override
241         public boolean keyPressed(KeyEvent e) {
242                 if (e.getKeyCode() == KeyEvent.VK_ESCAPE)
243                         panel.useDefaultAction();
244                 if (lock != LockType.CUSTOM || !lockForced) {
245                         if ((e.getModifiersEx() & KeyEvent.SHIFT_DOWN_MASK) > 0) {
246                                 if (e.getKeyCode() == KeyEvent.VK_X) {
247                                         if (lock != LockType.XY && lock != LockType.XZ) {
248                                                 setLockType(LockType.XY, false);
249                                         } else if (lock == LockType.XY) {
250                                                 setLockType(LockType.XZ, false);
251                                         } else {
252                                                 setLockType(LockType.NONE, false);
253                                         }
254                                 }
255                                 if (e.getKeyCode() == KeyEvent.VK_Y) {
256                                         if (lock != LockType.XY && lock != LockType.YZ) {
257                                                 setLockType(LockType.XY, false);
258                                         } else if (lock == LockType.XY) {
259                                                 setLockType(LockType.YZ, false);
260                                         } else {
261                                                 setLockType(LockType.NONE, false);
262                                         }
263                                 }
264                                 if (e.getKeyCode() == KeyEvent.VK_Z) {
265                                         if (lock != LockType.XZ && lock != LockType.YZ) {
266                                                 setLockType(LockType.XZ, false);
267                                         } else if (lock == LockType.XZ) {
268                                                 setLockType(LockType.YZ, false);
269                                         } else {
270                                                 setLockType(LockType.NONE, false);
271                                         }
272                                 }
273                         } else {
274                                 if (e.getKeyCode() == KeyEvent.VK_X) {
275                                         if (lock != LockType.X)
276                                                 setLockType(LockType.X,false);
277                                         else
278                                                 setLockType(LockType.NONE,false);
279                                 }
280                                 if (e.getKeyCode() == KeyEvent.VK_Y) {
281                                         if (lock != LockType.Y)
282                                                 setLockType(LockType.Y,false);
283                                         else
284                                                 setLockType(LockType.NONE, false);
285                                 }
286                                 if (e.getKeyCode() == KeyEvent.VK_Z) {
287                                         if (lock != LockType.Z)
288                                                 setLockType(LockType.Z, false);
289                                         else
290                                                 setLockType(LockType.NONE, false);
291                                 }
292                                 if (e.getKeyCode() == KeyEvent.VK_L && direction != null) {
293                                     if (lock != LockType.CUSTOM)
294                         setLockType(LockType.CUSTOM, false);
295                     else
296                         setLockType(LockType.NONE, false);
297                                 }
298                         }
299                 }
300                 if (e.getKeyCode() == KeyEvent.VK_C) {
301                         setUseDefault(!useDefault);
302                 }
303                 
304                 update();
305                 return true;
306         }
307         
308         private void setUseDefault(boolean b) {
309             useDefault = b;
310             if (useDefault)
311             setInfoText("Rotating camera");
312         if (cameraButton != null)
313             cameraButton.setSelection(useDefault);
314         }
315         
316         
317         private void update() {
318                 panel.refresh();
319         }
320         private void update(double x, double y) {
321                 switch (state) {
322                 case NOT_ACTIVE:
323                         return; // TODO : throw Exception?
324                 case INITIALIZING:
325                         return;
326                 case SELECTING_POSITION:
327                         return;
328                 case SELECTING_SPLIT:
329                         return;
330                 case ROUTING:
331                         updateRouting(x,y);
332                         break;
333                 }
334                 return;
335         }
336         
337         boolean startRemovable = false;
338         
339         protected void activate() throws Exception {
340                 state = ToolState.INITIALIZING;
341                 added.clear();
342                 
343                 if (allowed.size() == 1) {
344                         pipeRun = startComponent.getPipeRun();
345                         PipeControlPoint start = startComponent.getControlPoint();
346                         boolean requiresBranching = false;
347                         if (start.getNext() == null)
348                                 reversed = false;
349                         else if (start.getPrevious() == null) {
350                                 reversed = true;
351                         } else {
352                                 requiresBranching = true;
353                         }
354                         
355                         if (requiresBranching) {
356                                 activateSplit(start);
357                         } else {
358                                 activateNextPrev(start);
359                         }
360                 } else if (allowed.size() == 0) {
361                         panel.useDefaultAction();
362                         state = ToolState.NOT_ACTIVE;
363                         return;
364                 } else {
365                         terminalSelectionGizmo.setComponent(startComponent, allowed);
366                         terminalSelectionGizmo.attach(panel);
367                         state = ToolState.SELECTING_POSITION;
368                         update();
369                 }
370                 
371         }
372         
373         
374         
375         protected void activateNextPrev(PipeControlPoint start) throws Exception{
376                 if (!reversed && start.isDualInline())
377                         start = start.getDualSub();
378                 else if (reversed && start.isDualSub())
379                         start = start.parent;
380                 
381                 pipeRun = start.getPipeRun();
382                 setPreviousPosition(start.getWorldPosition());
383                 
384                 boolean startWithTurn = false;
385                 if (startComponent instanceof Nozzle) {
386                         direction = startComponent.getControlPoint().getDirectedControlPointDirection();
387                         lock = LockType.CUSTOM;
388                         lockForced = true;
389                 } else if (startComponent instanceof PipelineComponent){
390                         if (startComponent instanceof InlineComponent) {
391                                 direction = startComponent.getControlPoint().getPathLegDirection(reversed ? Direction.PREVIOUS : Direction.NEXT);
392                                 lock = LockType.CUSTOM;
393                                 lockForced = true;
394                                 if (((InlineComponent) startComponent).isVariableLength()) {
395                                         startWithTurn = true;
396                                         direction = null;
397                                         lock = LockType.NONE;
398                                         lockForced = false;
399                                 } 
400                                 Vector3d v = new Vector3d();
401                                 if (!reversed) {
402                                         start.getControlPointEnds(v, previousPosition);
403                                 } else {
404                                         start.getControlPointEnds(previousPosition,v);
405                                 }
406                         } else if (startComponent instanceof TurnComponent) {
407                                 if (start.asFixedAngle()) {
408                                         direction = startComponent.getControlPoint().getPathLegDirection(reversed ? Direction.PREVIOUS : Direction.NEXT);
409                                         lock = LockType.CUSTOM;
410                                         lockForced = start.isFixedAngle();
411                                 } else {
412                                         direction = null;
413                                         lock = LockType.NONE;
414                                         lockForced = false;
415                                 }
416                         } else if (startComponent instanceof EndComponent) {
417                                 throw new Exception("Not supported");
418                         }
419                         
420                 } else {
421                         throw new Exception("Not supported");
422                 }
423                 currentPosition = new Vector3d(previousPosition);
424                 state = ToolState.ROUTING;
425                 if (direction != null) {
426                         direction.normalize();
427                         
428                 } 
429                 startRemovable = start.isDeletable();
430                 start.setDeletable(false);
431                 
432                 if (startWithTurn) {
433                         addPoint();
434                 } else {
435                         if (direction != null)
436                                 currentPosition.add(direction);
437                         InlineComponent straight = ComponentUtils.createStraight(root);
438                         PipeControlPoint straightCP = straight.getControlPoint();
439                         straight.setName(pipeRun.getUniqueName("Pipe"));
440                         pipeRun.addChild(straight);
441                         added.add(straight);
442         
443                         if (!reversed) {
444                                 start.setNext(straightCP);
445                                 straightCP.setPrevious(start);
446                         } else {
447                                 start.setPrevious(straightCP);
448                                 straightCP.setNext(start);
449                         }
450                 }
451                 translateAxisGizmo.attach(panel);
452                 setPreviousPosition(previousPosition);
453                 updateCurrentPoint();
454                 updateWidget();
455         }
456         
457         protected void setPreviousPosition(Vector3d v) {
458                 previousPosition = new Vector3d(v);
459                 if (translateAxisGizmo.isAttached())
460                         translateAxisGizmo.setPosition(previousPosition);
461         }
462         
463         private void activateBranch(PipeControlPoint start) throws Exception{
464                 pipeRun = start.getPipeRun();
465                 setPreviousPosition(start.getWorldPosition());
466                 
467                 direction = null;
468                 lock = LockType.NONE;
469                 
470                 currentPosition = new Vector3d(previousPosition);
471                 state = ToolState.ROUTING;
472                 if (direction != null) {
473                         direction.normalize();
474                         
475                 } 
476                 startRemovable = start.isDeletable();
477                 start.setDeletable(false);
478                 
479                 
480                 if (direction != null)
481                         currentPosition.add(direction);
482                 InlineComponent straight = ComponentUtils.createStraight(root);
483                 PipeControlPoint straightCP = straight.getControlPoint();
484                 straight.setName(pipeRun.getUniqueName("Pipe"));
485                 pipeRun.addChild(straight);
486                 added.add(straight);
487
488                 if (!reversed) {
489                         start.setNext(straightCP);
490                         straightCP.setPrevious(start);
491                         
492                 } else {
493                         start.setPrevious(straightCP);
494                         straightCP.setNext(start);
495                         
496                 }
497                 
498                 translateAxisGizmo.attach(panel);
499                 setPreviousPosition(previousPosition);
500                 updateCurrentPoint();
501                 updateWidget();
502         }
503         
504         private void activateSplit(PipeControlPoint start) throws Exception{
505                 Point3d p1 = new Point3d();
506                 Point3d p2 = new Point3d();
507                 start.getInlineControlPointEnds(p1, p2);
508                 splitPointSelectionGizmo.setSplit(p1, p2);
509                 splitPointSelectionGizmo.attach(panel);
510                 state = ToolState.SELECTING_SPLIT;
511         }
512         public void deactivate() {
513             if (added.size() > 0) {
514             for (PipelineComponent component : added) {
515                         component.getControlPoint().setDeletable(true);
516                 }
517                 
518             for (PipelineComponent comp : added) {
519                 PipingRules.requestUpdate(comp.getControlPoint());
520             }
521             try {
522                 PipingRules.update();
523                 nodeMap.commit("Route pipe");
524             } catch (Exception e) {
525                 ExceptionUtils.logAndShowError(e);
526             }
527             added.clear();        
528         }
529                 
530                 startComponent.getControlPoint().setDeletable(startRemovable);
531
532                 direction = null;
533
534                 setLockType(LockType.NONE, true);
535                 startComponent = null;
536                 endTo = null;
537                 endPort = null;
538                 endType = null;
539                 pipeRun = null;
540                 allowed.clear();
541                 currentPosition = null;
542                 previousPosition = null;
543                 startRemovable = false;
544                 detector.clearConstraintHighlights();
545                 state = ToolState.NOT_ACTIVE;
546                 setEnabled(false);              
547
548         }
549         
550         private void setLockType(LockType type, boolean force) {
551             if (type == LockType.CUSTOM && (direction == null || added.size() > 0)) {
552                 // nothing to do..
553             } else if (force || (lock != LockType.CUSTOM || !lockForced || added.size() > 0) ) {
554                     
555                         lock = type;
556                         
557                         switch (lock) {
558                         case CUSTOM:
559                         case NONE:
560                                 translateAxisGizmo.setType(6);
561                                 break;
562                         case X:
563                                 translateAxisGizmo.setType(0);
564                                 break;
565                         case Y:
566                                 translateAxisGizmo.setType(1);
567                                 break;
568                         case Z:
569                                 translateAxisGizmo.setType(2);
570                                 break;
571                         case XY:
572                                 translateAxisGizmo.setType(3);
573                                 break;
574                         case XZ:
575                                 translateAxisGizmo.setType(4);
576                                 break;
577                         case YZ:
578                                 translateAxisGizmo.setType(5);
579                                 break;
580                                 
581                         }
582                         
583                 }
584                 updateWidget();
585         }
586         
587         private void updateWidget() {
588             if (axisCombo != null) {
589             axisCombo.select(lock.ordinal());
590             axisCombo.setEnabled(!lockForced || lock != LockType.CUSTOM);
591             }
592         }
593         
594         @Override
595         public boolean mousePressed(MouseEvent e) {
596                 if (useDefault) {
597                         getDefaultAction().mousePressed(e);
598                 }
599                 return true;
600         }
601
602         @Override
603         public boolean mouseReleased(MouseEvent e) {
604                 if (useDefault) {
605                         getDefaultAction().mouseReleased(e);
606                 }
607                 return true;
608         }
609         
610         @Override
611         public boolean mouseWheelMoved(MouseWheelEvent e) {
612                 if (useDefault) {
613                         getDefaultAction().mouseWheelMoved(e);
614                 }
615                 return true;
616         }
617         
618         @Override
619         public boolean mouseClicked(MouseEvent e) {
620                 if (useDefault) {
621                         getDefaultAction().mouseClicked(e);
622                         return true;
623                 }
624                 if (state == ToolState.ROUTING) {
625                         try {
626                                 if (e.getClickCount() == 1) {
627                                         if (e.getButton() == MouseEvent.BUTTON1) {
628                                                 if (this.added.size() > 0) {
629                                                         
630                                                         setLockType(LockType.NONE,true);
631                                                         if (endTo != null) {
632                                                                 
633                                                                 endPiping();
634                                                         } else {
635                                                                 addPoint();
636                                                         }
637                                                 } else {
638                                                         throw new RuntimeException("RoutePipeAction initialization has failed, no added components found");
639                 //                      // user was selecting position of branch
640                 //                    lastPoint.set(startPoint);
641                 //                    controlPoints.add(new Point3d(startPoint));
642                 //                    if (selectionLine != null)
643                 //                      selectionLine.removeFromParent();
644                 //                    selectionLine = null;
645                                                 }
646                                         } else if (e.getButton() ==MouseEvent.BUTTON2){
647                                             updateConstraints();
648                                         } else if (e.getButton() == MouseEvent.BUTTON3){      
649                                                 endPiping();
650                                         }
651                                 }
652                         } catch(Exception err) {
653                                 err.printStackTrace();
654                         }
655                 } else if (state == ToolState.SELECTING_POSITION) {
656                         if (e.getClickCount() == 1 && e.getButton() == MouseEvent.BUTTON1) {
657                                 int type = panel.getPickType();
658                                 //panel.setPickType(0);
659                                 panel.setPickType(5);
660                                 vtkProp[] picked = panel.pick(e.getX(), e.getY());
661                                 panel.setPickType(type);
662                                 PositionType position = terminalSelectionGizmo.getPickedPosition(picked);
663                                 if (position != null) {
664                                         terminalSelectionGizmo.deattach();
665                                         try {
666                                         if (position == PositionType.SPLIT) {
667                                                 activateSplit(startComponent.getControlPoint());
668                                         } else if (position == PositionType.NEXT || position == PositionType.PREVIOUS) {
669                                                 reversed = position == PositionType.PREVIOUS;
670                                                 activateNextPrev(startComponent.getControlPoint());
671                                         } else {
672                                                 panel.useDefaultAction();
673                                         }
674                                         } catch (Exception err) {
675                                                 ExceptionUtils.logAndShowError(err);
676                                                 panel.useDefaultAction();
677                                         }
678                                 }
679                         } 
680                 } else if (state == ToolState.SELECTING_SPLIT) {
681                         if (e.getClickCount() == 1 && e.getButton() == MouseEvent.BUTTON1) {
682                                 Tuple3d t = splitPointSelectionGizmo.getSplitPoint();
683                                 splitPointSelectionGizmo.deattach();
684                                 if (t == null) {
685                                         panel.useDefaultAction();
686                                         return true;
687                                 }
688                                 try {
689                                         Vector3d pos = new Vector3d(t);
690                                         InlineComponent branchSplit = ComponentUtils.createBranchSplit((InlineComponent)startComponent, pos);
691                                         PipeControlPoint branchSplitCP = branchSplit.getControlPoint();
692                                         reversed = false;
693                                         PipeRun newRun = new PipeRun();
694                                         String n = root.getUniqueName("PipeRun");
695                                         newRun.setName(n);
696                                         root.addChild(newRun);
697                                         PipeControlPoint pcp = new PipeControlPoint(branchSplit,newRun);
698                                         branchSplitCP.children.add(pcp);
699                                         pcp.parent = branchSplitCP;
700                                         pcp.setWorldOrientation(branchSplitCP.getWorldOrientation());
701                                         pcp.setWorldPosition(branchSplitCP.getWorldPosition());
702                                         startComponent = branchSplit;
703                                         activateBranch(pcp);
704                                 } catch (Exception err) {
705                                         ExceptionUtils.logAndShowError(err);
706                                         panel.useDefaultAction();
707                                 }
708                         }
709                 }
710                 return true;
711         }
712         
713         private void updateConstraints() {
714             detector.clearConstraints();
715             constraintPointGizmo.clearPositions();
716             if (hoverObject == null) {
717                 if (constraintPointGizmo.isAttached())
718                     constraintPointGizmo.deattach();
719                 return;
720             }
721             if (hoverObject instanceof Nozzle) {
722             Nozzle n = (Nozzle)hoverObject;
723             detector.addContraintPoint(new Point3d(n.getWorldPosition()));
724             } else if (hoverObject instanceof InlineComponent) {
725                 InlineComponent c = (InlineComponent)hoverObject;
726                 Point3d p1 = new Point3d();
727                 Point3d p2 = new Point3d();
728                 c.getEnds(p1, p2);
729                 detector.addContraintPoint(p1);
730                 detector.addContraintPoint(p2);
731                 detector.addContraintPoint(new Point3d(c.getWorldPosition()));
732             } else if (hoverObject instanceof TurnComponent) {
733                 TurnComponent n = (TurnComponent)hoverObject;
734             detector.addContraintPoint(new Point3d(n.getWorldPosition()));
735             }
736             if (detector.getConstraintPoints().size() > 0) {
737                 for (Point3d p : detector.getConstraintPoints()) {
738                     constraintPointGizmo.addPosition(new Vector3d(p));
739                 }
740                 if (constraintPointGizmo.isAttached())
741                     constraintPointGizmo.deattach();
742                 constraintPointGizmo.attach(panel);
743             }
744         }
745         
746         @Override
747         public boolean mouseMoved(MouseEvent e) {
748                 if (useDefault) {
749                         getDefaultAction().mouseMoved(e);
750                         return true;
751                 }
752                 step = ((e.getModifiers() & MouseEvent.CTRL_MASK) > 0);
753                 update(e.getX(), e.getY());
754                 return true;
755         }
756         
757         @Override
758         public boolean mouseDragged(MouseEvent e) {
759                 if (useDefault)
760                         getDefaultAction().mouseDragged(e);
761                 return true;
762         }
763         
764
765         
766         
767         private List<INode> isOverNode(int x, int y) {
768                 List<INode> nodes = new ArrayList<INode>(); 
769                 vtkProp picked[] = panel.pick2(x, y);
770                 if (picked !=null) {
771                         for (int i = 0; i < picked.length; i++) {
772                                 nodes.add(nodeMap.getNode(picked[i]));
773                         }
774                 }
775                 return nodes;
776         }
777         
778         INode hoverObject = null;
779
780         protected void updateRouting(double x, double y) {
781                 if (useDefault) {
782                         //panel.getDefaultAction().update();
783                         return;
784                 }
785                 
786                 endTo = null;
787                 endType = null;
788                 endPort = null;
789
790                 Ray ray = vtkUtil.createMouseRay(panel.getRenderer(),x, y);
791                 Vector3d o = new Vector3d(ray.pos);
792                 Vector3d d = ray.dir;
793                 
794                 
795                 if (!updateCurrentPoint(o, d))
796                         return;
797                 //Point3d startPoint = new Point3d();
798                 double mu[] = new double[2];
799                 
800                 
801                 
802                 
803                 
804                 List<INode> hover = isOverNode((int)x,(int)y);
805                 if (hover.size() > 0) {
806                         hoverObject = hover.get(0);
807                 } else {
808                     hoverObject = null;
809                 }
810 //              System.out.println(hoverObject + " " + getLast());
811                 if (hoverObject != null) {
812                         if (hoverObject.equals(getLast()) ) {
813                                 boolean set = false;
814                                 for (int i = 1; i < hover.size(); i++) {
815                                         hoverObject = hover.get(i);
816                                         if (!getLast().equals(hoverObject)) {
817                                                 set = true;
818                                                 break;
819                                         }
820                                 }
821                                 if (!set)
822                                         hoverObject = null;
823                         }
824                 }
825 //              System.out.println(hoverObject);
826                 if (hoverObject != null) {
827
828                         if (lock == LockType.NONE) {
829                                 if (hoverObject instanceof Nozzle && endingToNozzle(hoverObject,o,d)) {
830                                         endTo = (Nozzle)hoverObject;
831                                 } else if (hoverObject instanceof InlineComponent && ((InlineComponent)hoverObject).isVariableLength()) {
832                                         endTo = (InlineComponent)hoverObject;
833                                         endType = endingToStraight(endTo,mu,o,d);     
834                                         if (endType == null)
835                                             endTo = null;
836                                 } else if (hoverObject instanceof PipelineComponent && (endPort = endingToComponent(hoverObject,o,d)) != null) {
837                                         endTo = (PipelineComponent)hoverObject;
838                                 } else {
839                                         updateRoute(o,d); 
840                                 }
841                         } else {  
842                                 if (hoverObject instanceof InlineComponent && ((InlineComponent)hoverObject).isVariableLength() && (endType = endingLockToStraight(hoverObject,mu, new Point3d(currentPosition))) != null) {
843                                         endTo = (InlineComponent)hoverObject;
844                                 } else if (hoverObject instanceof Nozzle && endingLockToNozzle(hoverObject)) {
845                                         endTo = (Nozzle)hoverObject;
846                                 } else if ((hoverObject instanceof PipelineComponent) &&  ((endPort = endingLockToComponent(hoverObject)) != null)) {
847                                         endTo = (PipelineComponent)hoverObject;
848                                 } else {
849                                         updateRoute(o,d);
850                                 }
851                         }
852                         if (added.contains(endTo))
853                                 endTo = null;
854
855                 } else {
856                         updateRoute(o,d);
857                 }
858                 
859                 panel.refresh();
860         }
861         
862         protected boolean updateCurrentPoint(Vector3d o, Vector3d d) {
863
864                 Vector3d point = new Vector3d(this.previousPosition);
865                 
866                 switch(lock) {
867                 case X:
868                         MathTools.intersectStraightStraight(point, new Vector3d(1.0,0.0,0.0), o,d, currentPosition, new Vector3d());
869                         if (step) {
870                                 currentPosition.x = Math.round(istep * currentPosition.x) / istep;
871                                 BigDecimal bx = new BigDecimal(currentPosition.x);
872                                 bx.setScale(decimals, BigDecimal.ROUND_HALF_UP);
873                                 currentPosition.x = bx.doubleValue();
874                         }
875                         break;
876                 case Y:
877                         MathTools.intersectStraightStraight(point, new Vector3d(0.0,1.0,0.0), o,d, currentPosition, new Vector3d());
878                         if (step) {
879                                 currentPosition.y = Math.round(istep * currentPosition.y) / istep;
880                                 BigDecimal bx = new BigDecimal(currentPosition.y);
881                                 bx.setScale(decimals, BigDecimal.ROUND_HALF_UP);
882                                 currentPosition.y = bx.doubleValue();
883                         }
884                         break;
885                 case Z:
886                         MathTools.intersectStraightStraight(point, new Vector3d(0.0,0.0,1.0), o,d, currentPosition, new Vector3d());
887                         if (step) {
888                                 currentPosition.z = Math.round(istep * currentPosition.z) / istep;
889                                 BigDecimal bx = new BigDecimal(currentPosition.z);
890                                 bx.setScale(decimals, BigDecimal.ROUND_HALF_UP);
891                                 currentPosition.z = bx.doubleValue();
892                         }break;
893                 case XY:
894                         MathTools.intersectStraightPlane(o, d, point, new Vector3d(0.0,0.0,1.0), currentPosition);
895                         break;
896                 case XZ:
897                         MathTools.intersectStraightPlane(o, d, point, new Vector3d(0.0,1.0,0.0), currentPosition);
898                         break;
899                 case YZ:
900                         MathTools.intersectStraightPlane(o, d, point, new Vector3d(1.0,0.0,0.0), currentPosition);
901                         break;
902                 case NONE:
903                         Vector3d normal = new Vector3d(panel.getRenderer().GetActiveCamera().GetDirectionOfProjection());
904                         normal.normalize();
905                         
906                         MathTools.intersectStraightPlane(o, d, point, normal, currentPosition);
907                         break;
908                 case CUSTOM:
909                         MathTools.intersectStraightStraight(point, new Vector3d(direction), o,d, currentPosition, new Vector3d());
910                         double dist = MathTools.distanceFromPlane(new Vector3d(currentPosition), direction, previousPosition);
911                         if (dist < 0.0)
912                                 currentPosition.set(previousPosition);
913                         break;
914                 default:
915                         return false;
916                 }
917                 return true;
918         }
919         
920         @SuppressWarnings("unused")
921         private Vector3d getLockDir() {
922                 switch (lock) {
923                 case CUSTOM:
924                         return direction;
925                 case X:
926                         return new Vector3d(1,0,0);
927                 case Y:
928                         return new Vector3d(0,1,0);
929                 case Z:
930                         return new Vector3d(0,0,1);
931                 default:
932                         return null;
933                 }
934         }
935         
936         protected void updateRoute(Vector3d o, Vector3d d) {
937                 detector.clearConstraintHighlights();
938                 Point3d previousPipePoint = new Point3d(previousPosition);
939                 String s = "";
940                 if (lock == LockType.NONE) {
941                         Point3d p = detector.getSnappedPoint(o, d, new Vector3d(previousPipePoint));
942                         if (p != null)
943                                 currentPosition = new Vector3d(p);
944                         s += detector.getSnapString();
945
946                 } else {
947                         Vector3d dir = new Vector3d(currentPosition);
948                         dir.sub(previousPipePoint);
949                         Point3d p = detector.getPointSnap(new Vector3d(previousPipePoint), dir);
950                         if (p != null)
951                                 currentPosition = new Vector3d(p);
952                         s += detector.getSnapString();
953
954                 }
955 //              System.out.println(previousPosition + " -> " + currentPosition);
956 //              double dist = MathTools.distance(previousPosition, currentPosition);
957 //              if (dist < pipeRun.getTurnRadius()) {
958 //                      s += "Too close";
959 //                      Vector3d v = new Vector3d(currentPosition);
960 //                      v.sub(previousPosition);
961 //                      double vl = v.length();
962 //                      if (vl > MathTools.NEAR_ZERO) {
963 //                              v.scale(1.0/vl);
964 //                      } else {
965 //
966 //                              return;
967 //                      }
968 //                      v.scale(pipeRun.getTurnRadius());
969 //                      v.add(previousPosition);
970 //                      currentPosition.set(v);
971 //              }
972                 
973                 updateCurrentPoint();
974                 s += currentPosition.toString();
975                 setInfoText(s);
976         }
977         
978         vtkTextActor infoActor;
979         
980         private void setInfoText(String text) {
981                 //System.out.println(text);
982                 if (infoActor == null) {
983                         infoActor = new vtkTextActor();
984                         infoActor.GetTextProperty().SetColor(0.0, 0.0, 0.0);
985                         infoActor.GetTextProperty().ShadowOff();
986                         infoActor.GetTextProperty().ItalicOff();
987                         infoActor.GetTextProperty().BoldOff();
988                         infoActor.GetTextProperty().SetFontSize(18);
989                         infoActor.GetTextProperty().Delete();
990                         infoActor.GetProperty().SetColor(0.0, 0.0, 0.0);
991                         infoActor.GetProperty().Delete();
992
993                         
994                         infoActor.SetPosition(10,10);
995                         panel.getRenderer().AddActor(infoActor);
996                 }
997                 infoActor.SetInput(text);
998         }
999         
1000         private boolean endingToNozzle(INode nozzleNode,Vector3d o, Vector3d d) {
1001                 Nozzle nozzle = (Nozzle)nozzleNode;
1002                 PipeControlPoint pcp  =nozzle.getControlPoint();
1003                 if (pcp != null && (pcp.getNext() != null ||
1004                                                         pcp.getPrevious() != null))
1005                         return false; // nozzle is already connected to pipe
1006                 currentPosition = pcp.getWorldPosition();
1007                 Point3d previousPipePoint = new Point3d(previousPosition);
1008                 Point3d p = detector.getSnappedPoint(o, d, new Vector3d(previousPipePoint));
1009                 if (p != null) {
1010                         if (MathTools.distance(p, currentPosition) > NOZZLE_SNAP_DISTANCE) {
1011                                 return false;
1012                         }
1013                 } 
1014                 
1015                 updateCurrentPoint();
1016                 
1017                 setInfoText("Connect to nozzle " + currentPosition);
1018                 return true;
1019         
1020         }
1021         
1022         private PositionType endingToStraight(INode straightNode, double mu[], Vector3d o, Vector3d d) {
1023 //          if (!allowBranches) {
1024 //              updateCurrentPoint();
1025 //            return null;
1026 //          }
1027                 InlineComponent s = (InlineComponent)straightNode;
1028                 
1029                 Point3d sStart = new Point3d();
1030                 Point3d sEnd = new Point3d();
1031                 s.getEnds(sStart, sEnd);
1032                 //detector.clearConstraintHighlights();
1033                 
1034                 Point3d previousPipePoint = new Point3d(previousPosition);
1035                 Point3d currentPipePoint = new Point3d(currentPosition);
1036                 //String st = "";
1037                 if (lock == LockType.NONE) {
1038                         Point3d p = detector.getSnappedPoint(o, d, new Vector3d(previousPipePoint));
1039                         if (p != null) {
1040                                 currentPosition = new Vector3d(p);
1041                                 // snapping is detected, check if snapped point can create branch with straight
1042                                 PositionType t = endingLockToStraight(s, mu, currentPipePoint);
1043                                 if (t != null)
1044                                         return t;
1045                                 // if not, we'll have to remove highlight that was added when snapped point was detected
1046                                 detector.clearConstraintHighlights();   
1047                         }
1048                         
1049                         Vector3d sDir = new Vector3d(sEnd);
1050                         sDir.sub(sStart);
1051                         MathTools.intersectStraightStraight(sStart, sDir, o, d, currentPosition, new Point3d(), mu);
1052                         
1053
1054                 } else {
1055                         throw new RuntimeException("Lock shouldn't be on");
1056
1057                 }
1058                 
1059                 updateCurrentPoint();
1060                 
1061                 // branch point must lie between straight's ends. If connection point is exactly
1062                 // on straight end user may want to connect pipes to each other
1063                 // TODO : take account sizes of inline components)
1064                 return endingToStraight(mu, s, sStart, sEnd, currentPipePoint);
1065         }
1066         
1067         private PositionType endingToStraight(double mu[], InlineComponent s, Point3d sStart, Point3d sEnd , Point3d currentPipePoint) {
1068             String info = "";
1069             
1070             boolean connectPrev = false;
1071         boolean connectNext = false;
1072         boolean branch = false;
1073         if (mu[0] < 0.1) {
1074             connectPrev = true;
1075         }
1076         else if (mu[0] > 0.9) {
1077             connectNext = true;
1078         }
1079
1080           
1081         if (connectPrev) {
1082             PipeControlPoint pcp = s.getControlPoint();
1083             if (pcp.getPrevious() != null)
1084                 connectPrev = false;
1085         } else if (connectNext) {
1086             PipeControlPoint pcp = s.getControlPoint();
1087             if (pcp.getNext() != null)
1088                 connectNext = false;
1089         } else {
1090             Vector3d dir = s.getControlPoint().getPathLegDirection(Direction.NEXT);
1091             Vector3d currDir = getLast().getControlPoint().getPathLegDirection(Direction.NEXT);
1092             dir.normalize();
1093             currDir.normalize();
1094             double dot = dir.dot(currDir);
1095             System.out.println(dot + " " + currDir + " " + dir);
1096             if (dot > BRANCH_DOT_PRODUCT || dot < -BRANCH_DOT_PRODUCT) {
1097                 // pipes are almost in the same direction, creating a branch is not feasible.
1098                 branch = false;
1099             } else {
1100                 branch = true;
1101             }
1102         }
1103         
1104             
1105         if (connectNext || connectPrev)
1106             info += "Connect pipes :";
1107         else if (branch)
1108             info += "Create a Branch :";
1109         
1110         setInfoText(info + currentPosition + " " + Math.max(0.0, Math.min(mu[0], 1.0)));
1111         if (connectNext) {
1112             currentPosition.set(sEnd);
1113             updateCurrentPoint();
1114             return PositionType.NEXT;
1115         } else if (connectPrev){
1116             currentPosition.set(sStart);
1117             updateCurrentPoint();
1118             return PositionType.PREVIOUS;
1119         } else if (branch && allowBranches) {
1120             return PositionType.SPLIT;
1121         } else {
1122             currentPosition.set(currentPipePoint);
1123             updateCurrentPoint();
1124             return null;
1125         }
1126         }
1127         
1128         private PipeControlPoint endingToComponent(INode componentNode, Vector3d o, Vector3d d) {
1129                 PipelineComponent component = (PipelineComponent)componentNode;
1130                 PipeControlPoint pcp = component.getControlPoint();
1131                 PipeControlPoint connect = null;
1132                 if (component instanceof EndComponent) {
1133                         if (pcp.getNext() != null || pcp.getPrevious() != null)
1134                                 return null;
1135                         connect =  pcp;
1136                 } else if (component instanceof TurnComponent) {
1137                         if (pcp.getNext() == null || pcp.getPrevious() == null)
1138                                 connect = pcp;
1139                         else
1140                             return null;
1141                 } else if (component instanceof InlineComponent) {
1142                         // TODO : scan all empty pcps of the component and select closest one.
1143                         if (pcp.getNext() == null || pcp.getPrevious() == null)
1144                                 connect =  pcp;
1145                         else
1146                             return null;
1147                 }
1148                 if (connect != null) {
1149                     currentPosition.set(connect.getWorldPosition());
1150             updateCurrentPoint();
1151                     setInfoText("Connect to " + component.getName());
1152                     return connect;
1153                 }
1154                 return null;
1155         }
1156         
1157         private PositionType endingLockToStraight(INode straightNode, double mu[], Point3d currentPipePoint) {
1158 //          if (!allowBranches) {
1159 //            updateCurrentPoint();
1160 //            return null;
1161 //        }
1162                 InlineComponent s = (InlineComponent)straightNode;
1163                 Point3d sStart = new Point3d();
1164                 Point3d sEnd = new Point3d(); 
1165                 s.getControlPoint().getInlineControlPointEnds(sStart, sEnd);  
1166                 Vector3d sDir = new Vector3d(sEnd);
1167                 sDir.sub(sStart);
1168                 Vector3d dir = new Vector3d(currentPosition);
1169                 Point3d prev = new Point3d(previousPosition);
1170                 dir.sub(prev);
1171                 // intersection point in pipe where branch would be inserted to
1172                 Vector3d branchPoint = new Vector3d();
1173                 // intersection point in straight pipe that is currently routed
1174                 Vector3d routePoint = new Vector3d();
1175                 MathTools.intersectStraightStraight(sStart, sDir, new Vector3d(prev), dir, branchPoint, routePoint, mu);
1176                 routePoint.sub(branchPoint);
1177                 // startPoint of branch must be between pipe ends
1178                 // TODO : take account sizes of elbows (or other components)
1179                 // branch point must be between pipe ends and intersection points must be quite close to each other
1180                 
1181                 if (routePoint.lengthSquared() > BRANCH_SNAP_DISTANCE)
1182                     return null;
1183                 
1184                 return endingToStraight(mu, s, sStart, sEnd, currentPipePoint);
1185                 
1186 //              if (mu[0] > 0.0 && mu[0] < 1.0 && routePoint.lengthSquared() < BRANCH_SNAP_DISTANCE) {
1187 //                      currentPosition.set(branchPoint);
1188 //                      
1189 //                      updateCurrentPoint();
1190 //                      
1191 //                      setInfoText("Create a branch (l) :" + currentPosition + " " + Math.max(0.0, Math.min(mu[0], 1.0)) + " " + routePoint.lengthSquared());
1192 //                      return PositionType.SPLIT;
1193 //              }
1194 //              return null;
1195         }
1196         
1197         private boolean endingLockToNozzle(INode nozzleNode) {
1198                 Nozzle nozzle = (Nozzle)nozzleNode;
1199                 Vector3d dir = new Vector3d(currentPosition);
1200                 Point3d prev = new Point3d(previousPosition);
1201                 dir.sub(prev);
1202                 Vector3d nozzleLoc = nozzle.getWorldPosition();
1203                 double u[] = new double[1];
1204                 Vector3d closest = MathTools.closestPointOnStraight(new Point3d(nozzleLoc), new Point3d(prev), new Vector3d(dir), u);
1205                 double dist = MathTools.distanceSquared(nozzleLoc,closest);
1206                 if (dist < BRANCH_SNAP_DISTANCE) {
1207                         // FIXME : directions should be checked (insert an elbow)
1208                         currentPosition.set(nozzleLoc);
1209                         updateCurrentPoint();
1210                         setInfoText("Connect to nozzle (l) :" + currentPosition);
1211                         return true;
1212                 } 
1213                 //System.out.println(u[0]);
1214                 return false;
1215         }
1216         
1217         private PipeControlPoint endingLockToComponent(INode componentNode) {
1218                 // we'll must scan all free pcp's and their direction to accept the connection.
1219                 return null;
1220         }
1221         
1222         protected void addTurn() throws Exception{
1223             InlineComponent previous = (InlineComponent)getLast();
1224         PipeControlPoint previousCP = previous.getControlPoint();
1225         TurnComponent turn = ComponentUtils.createTurn(root);
1226         PipeControlPoint turnCP = turn.getControlPoint();
1227         turn.setName(pipeRun.getUniqueName("Elbow"));
1228         pipeRun.addChild(turn);
1229         added.add(turn);
1230         turnCP.setDeletable(false); // mark turnCP nonDeletable so that PipingRules won't delete it immediately.
1231         if (!reversed) {
1232             previousCP.setNext(turnCP);
1233             turnCP.setPrevious(previousCP);
1234         } else {
1235             previousCP.setPrevious(turnCP);
1236             turnCP.setNext(previousCP);
1237         }
1238         
1239         turnCP.setWorldPosition(currentPosition);
1240         turnCP.setTurnAngle(0.0);
1241         turnCP.setLength(0.0);
1242         
1243         }
1244         
1245         protected void addStraight() throws Exception{
1246         TurnComponent turn = (TurnComponent)getLast();
1247         PipeControlPoint turnCP = turn.getControlPoint();
1248         
1249         InlineComponent straight = ComponentUtils.createStraight(root);
1250         
1251         PipeControlPoint straightCP = straight.getControlPoint();
1252         straight.setName(pipeRun.getUniqueName("Pipe"));
1253         
1254         
1255         pipeRun.addChild(straight);
1256         
1257         added.add(straight);
1258         
1259         
1260         
1261         if (!reversed) {
1262             turnCP.setNext(straightCP);
1263             straightCP.setPrevious(turnCP);
1264         } else {
1265             turnCP.setPrevious(straightCP);
1266             straightCP.setNext(turnCP);
1267         }
1268         
1269         turnCP.setWorldPosition(currentPosition);
1270         turnCP.setTurnAngle(0.0);
1271         turnCP.setLength(0.0);
1272         straightCP.setWorldPosition(currentPosition);
1273         straightCP.setLength(0.0);
1274             
1275         }
1276         
1277         protected void addPoint() throws Exception {
1278                 addTurn();
1279                 addStraight();
1280                 setPreviousPosition(currentPosition);
1281                 updateCurrentPoint();
1282                 
1283                 
1284                 
1285         }
1286         
1287         /**
1288          * Updates tool graphics for current point 
1289          */
1290         protected void updateCurrentPoint() {
1291                 InlineComponent straight = (InlineComponent)added.get(added.size()-1);
1292                 // TODO: the inline length is from previous update step.
1293                 double l;
1294                 if (!reversed)
1295                         l = straight.getPrevious().getControlPoint().getInlineLength();
1296                 else
1297                         l = straight.getNext().getControlPoint().getInlineLength();
1298                 Vector3d v = new Vector3d();
1299                 v.sub(currentPosition, previousPosition);
1300                 double length = v.length();
1301                 if (length > MathTools.NEAR_ZERO) {
1302                         v.scale(1.0/length);
1303                         v.scale(0.5*(length+l));
1304                         v.add(previousPosition);
1305                         straight.getControlPoint().setWorldPosition(v);
1306                         straight.getControlPoint().setLength(length);
1307                 }
1308                 try {
1309                         PipingRules.positionUpdate(straight.getControlPoint(),false);
1310                 } catch (Exception e) {
1311                         // TODO Auto-generated catch block
1312                         e.printStackTrace();
1313                 }
1314         }
1315         
1316         private PipelineComponent getLast() {
1317                 if (added.size() == 0)
1318                         return startComponent;
1319                 return added.get(added.size()-1);
1320         }
1321         
1322         
1323         /**
1324          * Removes last point from pipeline
1325          */
1326         public void removePoint() {
1327                 if (added.size() < 3)
1328                         return;
1329                 InlineComponent straight = (InlineComponent)added.remove(added.size()-1);
1330                 TurnComponent turn = (TurnComponent)added.remove(added.size()-1);
1331                 straight.getControlPoint().remove();
1332                 turn.getControlPoint().remove();
1333                 if (added.size() > 1) {
1334                         setPreviousPosition(added.get(added.size()-2).getWorldPosition());
1335                 } else {
1336                         setPreviousPosition(startComponent.getWorldPosition());
1337                         if (direction != null)
1338                                 setLockType(LockType.CUSTOM, true);
1339                 }
1340                 
1341         }
1342         
1343         protected void endPiping() throws Exception {
1344                 state = ToolState.NOT_ACTIVE;
1345                 
1346                 if (endTo != null) {
1347                     if (endType == PositionType.NEXT || endType == PositionType.PREVIOUS && endTo instanceof InlineComponent) {
1348                         Vector3d dir = endTo.getControlPoint().getPathLegDirection(Direction.NEXT);
1349                     Vector3d currDir = getLast().getControlPoint().getPathLegDirection(Direction.NEXT);
1350                     dir.normalize();
1351                     currDir.normalize();
1352                     double dot = dir.dot(currDir);
1353                     System.out.println(dot + " " + currDir + " " + dir);
1354                     if (dot < ALIGN_DOT_PRODUCT && dot> -ALIGN_DOT_PRODUCT) {
1355                         addTurn();    
1356                     }
1357                         
1358                     }
1359                         ComponentUtils.connect(getLast(), endTo, endType, currentPosition);
1360                 }
1361                 panel.useDefaultAction();
1362         }
1363 }