org.simantics.plant3d/src/org/simantics/plant3d/actions/AddComponentAction.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.util.HashSet;
   7 import java.util.Set;
   8
   9 import javax.vecmath.Vector3d;
  10
  11 import org.eclipse.swt.widgets.Display;
  12 import org.simantics.g3d.scenegraph.NodeMap;
  13 import org.simantics.g3d.scenegraph.base.INode;
  14 import org.simantics.g3d.vtk.swt.InteractiveVtkComposite;
  15 import org.simantics.g3d.vtk.swt.vtkSwtAction;
  16 import org.simantics.plant3d.Activator;
  17 import org.simantics.plant3d.dialog.ComponentSelectionDialog;
  18 import org.simantics.plant3d.gizmo.TerminalSelectionGizmo;
  19 import org.simantics.plant3d.scenegraph.InlineComponent;
  20 import org.simantics.plant3d.scenegraph.Nozzle;
  21 import org.simantics.plant3d.scenegraph.P3DRootNode;
  22 import org.simantics.plant3d.scenegraph.PipeRun;
  23 import org.simantics.plant3d.scenegraph.PipelineComponent;
  24 import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint;
  25 import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint.Direction;
  26 import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint.PositionType;
  27 import org.simantics.plant3d.scenegraph.controlpoint.PipingRules;
  28 import org.simantics.plant3d.utils.ComponentUtils;
  29 import org.simantics.plant3d.utils.Item;
  30 import org.simantics.plant3d.utils.Item.Type;
  31 import org.simantics.utils.threads.ThreadUtils;
  32 import org.simantics.utils.ui.ExceptionUtils;
  33
  34 import vtk.vtkProp;
  35
  36 public class AddComponentAction extends vtkSwtAction {
  37
  38
  39         private P3DRootNode root;
  40         private PipelineComponent component;
  41         private NodeMap<vtkProp,INode> nodeMap;
  42
  43         private TerminalSelectionGizmo gizmo;
  44
  45         private Set<PositionType> allowed = new HashSet<PositionType>();
  46
  47         private Item toAdd = null;
  48         private PositionType insertPosition;
  49         private boolean insertAdjustable;
  50         private boolean lengthAdjustable;
  51
  52         public AddComponentAction(InteractiveVtkComposite panel, P3DRootNode root) {
  53                 super(panel);
  54                 this.root = root;
  55                 setText("Add Component");
  56                 setImageDescriptor(Activator.imageDescriptorFromPlugin(Activator.PLUGIN_ID, "icons/Component.png"));
  57                 nodeMap = root.getNodeMap();
  58                 gizmo = new TerminalSelectionGizmo(panel);
  59         }
  60
  61         public void setComponent(PipelineComponent component) {
  62                 this.component = component;
  63
  64                 allowed.clear();
  65                 if (component instanceof Nozzle) {
  66                     if (component.getNext() == null && component.getPrevious() == null) {
  67                     allowed.add(PositionType.NEXT);
  68                 }
  69                 } else {
  70                 if (component.getNext() == null) {
  71                         allowed.add(PositionType.NEXT);
  72                 }
  73                 if (component.getPrevious() == null) {
  74                         allowed.add(PositionType.PREVIOUS);
  75                 }
  76                 if (component instanceof InlineComponent && !component.getControlPoint().isFixed()){
  77                         allowed.add(PositionType.SPLIT);
  78                 }
  79                 }
  80                 setEnabled(allowed.size() > 0);
  81         }
  82
  83         private Double length;
  84         private Double angle;
  85         private Double diameter;
  86         private Double turnRadius;
  87
  88         @Override
  89         public void run() {
  90
  91                 ComponentSelectionDialog dialog = new ComponentSelectionDialog(Display.getCurrent().getActiveShell(), allowed, component);
  92                 if (dialog.open() == ComponentSelectionDialog.CANCEL)
  93                         return;
  94                 toAdd = dialog.getSelected();
  95                 if (toAdd == null)
  96                         return;
  97                 this.insertPosition = dialog.getInsertPosition();
  98                 this.insertAdjustable = dialog.isInsertAdjustable();
  99                 this.lengthAdjustable = dialog.isLenghtAdjustable();
 100                 this.length = dialog.getLength();
 101                 this.angle = dialog.getAngle();
 102                 this.diameter = dialog.getDiameter();
 103                 this.turnRadius = dialog.getTurnRadius();
 104                 allowed = dialog.filterAllowed();
 105                 gizmo.setComponent(component, allowed);
 106                 super.run();
 107                 panel.refresh();
 108         }
 109
 110         @Override
 111         public boolean keyPressed(KeyEvent e) {
 112                 if (e.getKeyCode() == KeyEvent.VK_ESCAPE)
 113                         panel.useDefaultAction();
 114                 return true;
 115
 116         }
 117
 118         public void attach() {
 119                 if (component == null)
 120                         return;
 121
 122                 super.attach();
 123                 ThreadUtils.asyncExec(panel.getThreadQueue(), new Runnable() {
 124                         public void run() {
 125                                 attachUI();
 126                         }
 127                 });
 128
 129         }
 130
 131         public void deattach() {
 132 //              deactivate();
 133                 component = null;
 134                 nodeMap.commit("Add component");
 135                 deattachUI();
 136                 super.deattach();
 137                 panel.refresh();
 138         }
 139
 140         private void attachUI() {
 141                 //panel.setCursor(activeCursor);
 142                 gizmo.attach(panel);
 143         }
 144
 145         private void deattachUI() {
 146                 //panel.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
 147                 gizmo.deattach();
 148         }
 149
 150         @Override
 151         public boolean mouseMoved(MouseEvent e) {
 152                 return getDefaultAction().mouseMoved(e);
 153         }
 154
 155         @Override
 156         public boolean mousePressed(MouseEvent e) {
 157                 return getDefaultAction().mousePressed(e);
 158         }
 159
 160         @Override
 161         public boolean mouseReleased(MouseEvent e) {
 162                 return getDefaultAction().mouseReleased(e);
 163         }
 164
 165         @Override
 166         public boolean mouseDragged(MouseEvent e) {
 167                 return getDefaultAction().mouseDragged(e);
 168         }
 169
 170         public void doInsert(PositionType position) {
 171                 try  {
 172                         PipelineComponent newComponent = ComponentUtils.createComponent(root,toAdd.getUri());
 173                         PipeControlPoint newPcp = newComponent.getControlPoint();
 174
 175                         PipeControlPoint toPcp = component.getControlPoint();
 176                         PipeRun pipeRun = toPcp.getPipeRun();
 177
 178                         Vector3d dir = null;
 179                         Vector3d pos = null;
 180
 181
 182                         if (toPcp.isInline()) {
 183                             switch (position) {
 184                     case NEXT:
 185                         if (toPcp.isDualInline())
 186                             toPcp = toPcp.getSubPoint().get(0);
 187
 188                         break;
 189                     case PREVIOUS:
 190                         if (toPcp.isDualSub())
 191                             toPcp = toPcp.parent;
 192                     }
 193                             Vector3d start = new Vector3d();
 194                             Vector3d end = new Vector3d();
 195                     dir = new Vector3d();
 196                     toPcp.getInlineControlPointEnds(start, end, dir);
 197                     dir.normalize();
 198                     if (!insertAdjustable || insertPosition == PositionType.NEXT) {
 199                     switch (position) {
 200                     case NEXT:
 201                         pos = new Vector3d(end);
 202                         break;
 203                     case PREVIOUS:
 204                         pos = new Vector3d(start);
 205                         break;
 206                     case SPLIT:
 207                         break;
 208                     }
 209                     } else if (insertPosition == PositionType.SPLIT) {
 210                         pos = new Vector3d(toPcp.getWorldPosition());
 211                     } else {
 212                         switch (position) {
 213                     case NEXT:
 214                         pos = new Vector3d(start);
 215                         break;
 216                     case PREVIOUS:
 217                         pos = new Vector3d(end);
 218                         break;
 219                     case SPLIT:
 220                         break;
 221                     }
 222                     }
 223
 224                         } else if (toPcp.isDirected()) {
 225                             dir = new Vector3d(toPcp.getDirection(Direction.NEXT));
 226                             pos = new Vector3d(toPcp.getWorldPosition());
 227                         } else if (toPcp.isTurn() && toPcp.isFixed()) {
 228                             dir = new Vector3d(toPcp.getDirection(position == PositionType.NEXT ? Direction.NEXT : Direction.PREVIOUS));
 229                 pos = new Vector3d(toPcp.getWorldPosition());
 230                 if (!lengthAdjustable || insertPosition == PositionType.NEXT) {
 231                     Vector3d v = new Vector3d(dir);
 232                     v.scale(toPcp.getInlineLength());
 233                     pos.add(v);
 234                 }
 235                         }
 236
 237
 238                         if (!toAdd.isSizeChange()) {
 239                                 String name = component.getPipeRun().getUniqueName(toAdd.getName());
 240                                 newComponent.setName(name);
 241
 242                                 pipeRun.addChild(newComponent);
 243                                 if (toAdd.isVariable()) {
 244                                         // TODO: these options are not stored into DB. Should they?!
 245                                         if (toAdd.getType() == Type.INLINE) {
 246                                                 newPcp.setLength(length);
 247 //                                              newPcp.setFixed(true);
 248                                         } else if (toAdd.getType() == Type.TURN) {
 249                                                 newPcp.setTurnAngle(angle);
 250 //                                              newPcp.setFixed(true);
 251                                         }
 252                                 }
 253                                 newComponent.updateParameters();
 254
 255                             Vector3d v = new Vector3d(dir);
 256                             if (insertAdjustable) {
 257                             if (insertPosition == PositionType.NEXT)
 258                                 v.scale(newComponent.getControlPoint().getInlineLength());
 259                             else if (insertPosition == PositionType.SPLIT)
 260                                 v.set(0, 0, 0);
 261                             else if (insertPosition == PositionType.PREVIOUS)
 262                                 v.scale(-newComponent.getControlPoint().getInlineLength());
 263                             } else {
 264                                 v.scale(newComponent.getControlPoint().getInlineLength());
 265                             }
 266                 switch (position) {
 267                 case NEXT:
 268                     pos.add(v);
 269                     break;
 270                 case PREVIOUS:
 271                     pos.sub(v);
 272                     break;
 273                 case SPLIT:
 274                     break;
 275                 }
 276
 277                                 switch (position) {
 278                                 case NEXT:
 279                                         if (toPcp.isDualInline())
 280                                                 toPcp = toPcp.getSubPoint().get(0);
 281                                         newPcp.insert(toPcp, Direction.NEXT);
 282                                         newPcp.setWorldPosition(pos);
 283                                         break;
 284                                 case PREVIOUS:
 285                                         if (toPcp.isDualSub())
 286                                                 toPcp = toPcp.parent;
 287                                         newPcp.insert(toPcp, Direction.PREVIOUS);
 288                                         newPcp.setWorldPosition(pos);
 289                                         break;
 290                                 case SPLIT:
 291                                         PipingRules.splitVariableLengthComponent(newComponent, (InlineComponent)component, true);
 292                                 }
 293                         } else {
 294                                 PipeRun other = new PipeRun();
 295                                 String n = root.getUniqueName("PipeRun");
 296                                 other.setName(n);
 297                                 other.setPipeDiameter(diameter);
 298                                 other.setTurnRadius(turnRadius);
 299                                 root.addChild(other);
 300
 301
 302                                 if (position == PositionType.NEXT) {
 303                                         PipingRules.addSizeChange(false, pipeRun, other, (InlineComponent)newComponent, toPcp, null);
 304                         } else if (position == PositionType.PREVIOUS){
 305                                 PipingRules.addSizeChange(true, pipeRun, other, (InlineComponent)newComponent, toPcp, null);
 306                         }
 307                                 newPcp.setWorldPosition(pos);
 308                                 // TODO : chicken-egg problem
 309                                 newComponent.updateParameters();
 310                             Vector3d v = new Vector3d(dir);
 311                 v.scale(newComponent.getControlPoint().getLength()*0.5);
 312                 switch (position) {
 313                 case NEXT:
 314                     pos.add(v);
 315                     break;
 316                 case PREVIOUS:
 317                     pos.sub(v);
 318                     break;
 319                 case SPLIT:
 320                     break;
 321                 }
 322                 newPcp.setWorldPosition(pos);
 323
 324                         }
 325
 326
 327                 } catch (Exception e) {
 328                         ExceptionUtils.logAndShowError("Cannot add component", e);
 329                 }
 330         }
 331
 332         public boolean mouseClicked(MouseEvent e) {
 333                 if (e.getClickCount() == 1 && e.getButton() == MouseEvent.BUTTON1) {
 334                         int type = panel.getPickType();
 335                         //panel.setPickType(0);
 336                         panel.setPickType(5);
 337                         vtkProp[] picked = panel.pick(e.getX(), e.getY());
 338                         panel.setPickType(type);
 339                         PositionType position = gizmo.getPickedPosition(picked);
 340
 341                         if (position != null) {
 342                                 doInsert(position);
 343                                 panel.useDefaultAction();
 344                                 return true;
 345                         }
 346                 }
 347                 return getDefaultAction().mouseClicked(e);
 348         }
 349
 350         @Override
 351         public boolean mouseWheelMoved(MouseWheelEvent e) {
 352             return getDefaultAction().mouseWheelMoved(e);
 353         }
 354 }