import javax.vecmath.Tuple3d;
import javax.vecmath.Vector3d;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Combo;
+import org.eclipse.swt.widgets.Label;
import org.simantics.db.Resource;
import org.simantics.g3d.math.MathTools;
import org.simantics.g3d.math.Ray;
import org.simantics.g3d.scenegraph.NodeMap;
import org.simantics.g3d.scenegraph.base.INode;
+import org.simantics.g3d.toolbar.ToolComposite;
import org.simantics.g3d.tools.ConstraintDetector;
import org.simantics.g3d.vtk.gizmo.TranslateAxisGizmo;
import org.simantics.g3d.vtk.swt.InteractiveVtkComposite;
public class RoutePipeAction extends vtkSwtAction {
enum LockType {
- X, Y, Z, XY, YZ, XZ, NONE, CUSTOM
+ X, Y, Z, XY, XZ, YZ, NONE, CUSTOM
};
LockType lock = LockType.NONE;
private Set<PositionType> allowed = new HashSet<PositionType>();
- public RoutePipeAction(InteractiveVtkComposite panel, P3DRootNode root) {
- this(panel,root, true);
+ protected ToolComposite toolComposite;
+ protected Combo axisCombo;
+ protected Button cameraButton;
+
+ public RoutePipeAction(InteractiveVtkComposite panel, P3DRootNode root, ToolComposite toolComposite) {
+ this(panel,root, toolComposite, true);
}
- public RoutePipeAction(InteractiveVtkComposite panel, P3DRootNode root, boolean allowBranches) {
+ public RoutePipeAction(InteractiveVtkComposite panel, P3DRootNode root, ToolComposite toolComposite, boolean allowBranches) {
super(panel);
this.root = root;
this.allowBranches = allowBranches;
terminalSelectionGizmo = new TerminalSelectionGizmo(panel);
constraintPointGizmo = new ConstraintPointGizmo(panel);
detector = new org.simantics.g3d.vtk.swt.ConstraintDetector(panel);
+ this.toolComposite = toolComposite;
}
public void setComponent(PipelineComponent component) {
setEnabled(allowed.size() > 0);
}
- public void deattach() {
- deactivate();
- startComponent = null;
-
- deattachUI();
- super.deattach();
- panel.refresh();
- }
+ protected void createTools(ToolComposite toolComposite) {
+ Label label = new Label(toolComposite, SWT.READ_ONLY);
+ label.setText("Route direction:");
+ axisCombo = new Combo(toolComposite, SWT.READ_ONLY);
+ axisCombo.add("X");
+ axisCombo.add("Y");
+ axisCombo.add("Z");
+ axisCombo.add("XY");
+ axisCombo.add("XZ");
+ axisCombo.add("YZ");
+ axisCombo.add("None");
+ axisCombo.add("Custom");
+ axisCombo.addSelectionListener(new SelectionAdapter() {
+ @Override
+ public void widgetSelected(SelectionEvent e) {
+ Combo c = (Combo)e.getSource();
+ setLockType(LockType.values()[c.getSelectionIndex()],false);
+ panel.getComponent().setFocus();
+
+ }
+ });
+ axisCombo.select(lock.ordinal());
+ cameraButton = new Button(toolComposite, SWT.TOGGLE);
+ cameraButton.setText("Camera");
+ cameraButton.setSelection(useDefault);
+ cameraButton.addSelectionListener(new SelectionAdapter() {
+ @Override
+ public void widgetSelected(SelectionEvent e) {
+ setUseDefault(((Button)e.getSource()).getSelection());
+ panel.getComponent().setFocus();
+ }
+ });
+ Button close = new Button(toolComposite, SWT.PUSH);
+ close.setText("Close");
+ close.addSelectionListener(new SelectionAdapter() {
+ public void widgetSelected(SelectionEvent e) {
+ panel.useDefaultAction();
+ };
+ });
+ toolComposite.relayout();
+ }
+
+ public void deattach() {
+ deactivate();
+ setDBUndo(true);
+ if (toolComposite != null) {
+ toolComposite.clear();
+ axisCombo = null;
+ cameraButton = null;
+ }
+
+ startComponent = null;
+
+ deattachUI();
+ super.deattach();
+ panel.refresh();
+ }
public void attach() {
if (startComponent == null)
return;
-
+ if (toolComposite != null) {
+ createTools(toolComposite);
+ }
+ setDBUndo(false);
super.attach();
ThreadUtils.asyncExec(panel.getThreadQueue(), new Runnable() {
public void run() {
}
}
if (e.getKeyCode() == KeyEvent.VK_C) {
- useDefault = !useDefault;
- if (useDefault)
- setInfoText("Rotating camera");
- System.out.println("UseDefault " + useDefault);
+ setUseDefault(!useDefault);
}
-
-
-
update();
return true;
}
+ private void setUseDefault(boolean b) {
+ useDefault = b;
+ if (useDefault)
+ setInfoText("Rotating camera");
+ if (cameraButton != null)
+ cameraButton.setSelection(useDefault);
+ }
+
private void update() {
panel.refresh();
protected void activateNextPrev(PipeControlPoint start) throws Exception{
if (!reversed && start.isDualInline())
- start = start.getSubPoint().get(0);
+ start = start.getDualSub();
else if (reversed && start.isDualSub())
start = start.parent;
lockForced = true;
} else if (startComponent instanceof PipelineComponent){
if (startComponent instanceof InlineComponent) {
- direction = startComponent.getControlPoint().getPathLegDirection(reversed ? Direction.PREVIOUS : Direction.NEXT);
+ direction = startComponent.getControlPoint().getInlineDir();
+ if (reversed) direction.negate();
lock = LockType.CUSTOM;
lockForced = true;
if (((InlineComponent) startComponent).isVariableLength()) {
translateAxisGizmo.attach(panel);
setPreviousPosition(previousPosition);
updateCurrentPoint();
+ updateWidget();
}
protected void setPreviousPosition(Vector3d v) {
translateAxisGizmo.attach(panel);
setPreviousPosition(previousPosition);
updateCurrentPoint();
+ updateWidget();
}
private void activateSplit(PipeControlPoint start) throws Exception{
}
private void setLockType(LockType type, boolean force) {
- if (force || (lock != LockType.CUSTOM || !lockForced) ) {
+ if (type == LockType.CUSTOM && (direction == null || added.size() > 0)) {
+ // nothing to do..
+ } else if (force || (lock != LockType.CUSTOM || !lockForced || added.size() > 0) ) {
+
lock = type;
switch (lock) {
break;
}
+
}
+ updateWidget();
+ }
+
+ private void updateWidget() {
+ if (axisCombo != null) {
+ axisCombo.select(lock.ordinal());
+ axisCombo.setEnabled(!lockForced || lock != LockType.CUSTOM);
+ }
}
@Override
addPoint();
}
} else {
- throw new RuntimeException("RoutePipeAction initlialization has been failed, no added components found");
+ throw new RuntimeException("RoutePipeAction initialization has failed, no added components found");
// // user was selecting position of branch
// lastPoint.set(startPoint);
// controlPoints.add(new Point3d(startPoint));
return true;
}
+ @SuppressWarnings("unused")
private Vector3d getLockDir() {
switch (lock) {
case CUSTOM:
return new Vector3d(0,1,0);
case Z:
return new Vector3d(0,0,1);
+ default:
+ return null;
}
- return null;
}
protected void updateRoute(Vector3d o, Vector3d d) {
private PipeControlPoint endingToComponent(INode componentNode, Vector3d o, Vector3d d) {
PipelineComponent component = (PipelineComponent)componentNode;
PipeControlPoint pcp = component.getControlPoint();
+ PipeControlPoint connect = null;
if (component instanceof EndComponent) {
if (pcp.getNext() != null || pcp.getPrevious() != null)
return null;
- return pcp;
+ connect = pcp;
} else if (component instanceof TurnComponent) {
if (pcp.getNext() == null || pcp.getPrevious() == null)
- return pcp;
- return null;
+ connect = pcp;
+ else
+ return null;
} else if (component instanceof InlineComponent) {
// TODO : scan all empty pcps of the component and select closest one.
if (pcp.getNext() == null || pcp.getPrevious() == null)
- return pcp;
- return null;
+ connect = pcp;
+ else
+ return null;
+ }
+ if (connect != null) {
+ currentPosition.set(connect.getWorldPosition());
+ updateCurrentPoint();
+ setInfoText("Connect to " + component.getName());
+ return connect;
}
-
return null;
}