org.simantics.plant3d/src/org/simantics/plant3d/dialog/ComponentSelectionDialog.java

   1 package org.simantics.plant3d.dialog;
   2
   3 import java.util.Collection;
   4 import java.util.HashSet;
   5 import java.util.List;
   6 import java.util.Set;
   7
   8 import org.eclipse.jface.dialogs.Dialog;
   9 import org.eclipse.jface.dialogs.IDialogConstants;
  10 import org.eclipse.jface.dialogs.IDialogSettings;
  11 import org.eclipse.jface.layout.GridDataFactory;
  12 import org.eclipse.jface.layout.GridLayoutFactory;
  13 import org.eclipse.jface.resource.JFaceResources;
  14 import org.eclipse.jface.resource.LocalResourceManager;
  15 import org.eclipse.jface.resource.ResourceLocator;
  16 import org.eclipse.jface.resource.ResourceManager;
  17 import org.eclipse.jface.viewers.ISelectionChangedListener;
  18 import org.eclipse.jface.viewers.IStructuredSelection;
  19 import org.eclipse.jface.viewers.ListViewer;
  20 import org.eclipse.jface.viewers.SelectionChangedEvent;
  21 import org.eclipse.jface.viewers.StructuredSelection;
  22 import org.eclipse.swt.SWT;
  23 import org.eclipse.swt.events.KeyAdapter;
  24 import org.eclipse.swt.events.KeyEvent;
  25 import org.eclipse.swt.events.SelectionAdapter;
  26 import org.eclipse.swt.events.SelectionEvent;
  27 import org.eclipse.swt.layout.GridData;
  28 import org.eclipse.swt.layout.GridLayout;
  29 import org.eclipse.swt.widgets.Button;
  30 import org.eclipse.swt.widgets.Composite;
  31 import org.eclipse.swt.widgets.Control;
  32 import org.eclipse.swt.widgets.ExpandBar;
  33 import org.eclipse.swt.widgets.ExpandItem;
  34 import org.eclipse.swt.widgets.Label;
  35 import org.eclipse.swt.widgets.Shell;
  36 import org.eclipse.swt.widgets.Text;
  37 import org.simantics.Simantics;
  38 import org.simantics.db.Session;
  39 import org.simantics.db.exception.DatabaseException;
  40 import org.simantics.plant3d.Activator;
  41 import org.simantics.plant3d.ontology.Plant3D;
  42 import org.simantics.plant3d.scenegraph.EndComponent;
  43 import org.simantics.plant3d.scenegraph.InlineComponent;
  44 import org.simantics.plant3d.scenegraph.Nozzle;
  45 import org.simantics.plant3d.scenegraph.PipelineComponent;
  46 import org.simantics.plant3d.scenegraph.TurnComponent;
  47 import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint.PositionType;
  48 import org.simantics.plant3d.utils.Item;
  49 import org.simantics.plant3d.utils.Item.Type;
  50 import org.simantics.plant3d.utils.P3DUtil;
  51 import org.simantics.utils.ui.ExceptionUtils;
  52
  53 public class ComponentSelectionDialog extends Dialog implements ISelectionChangedListener {
  54
  55         private static final String DIALOG = "ComponentSelectionDialog"; //$NON-NLS-1$
  56
  57         private IDialogSettings dialogSettings;
  58
  59         private double lengthFactor = 1.0;
  60
  61         private ResourceManager resourceManager;
  62
  63         private String libUri;
  64
  65         private Item selected;
  66         private Set<PositionType> allowed;
  67         private Set<PositionType> filterAllowed;
  68         // private boolean positionAdjustment;
  69         private PipelineComponent component;
  70         private boolean insertAdjustable;
  71         private boolean lenghtAdjustable;
  72         private PositionType insertPosition = PositionType.NEXT;
  73
  74         private Double angle;
  75         private Double length;
  76         private Double rotationAngle;
  77
  78         private String name;
  79
  80         private Text nameText;
  81
  82         // In-line component
  83         private Text lengthText;
  84         // Turn component
  85         private Text angleText;
  86         // Rotated In-line, or turn component.
  87         private Text rotationAngleText;
  88
  89         // Input for new PipeRun
  90         private Double diameter;
  91         private Double thickness;
  92         private Double turnRadius;
  93
  94         private Text diameterText;
  95         private Text thicknessText;
  96         private Text turnRadiusText;
  97
  98         // Validation message label
  99         private Label validationLabel;
 100
 101         // Position selection
 102         private Button startButton;
 103         private Button middleButton;
 104         private Button endButton;
 105
 106         private boolean inlineSplit = false;
 107
 108         ListViewer inlineViewer;
 109         ListViewer turnViewer;
 110         ListViewer endViewer;
 111
 112         private Set<String> usedNames;
 113
 114         public ComponentSelectionDialog(Shell parentShell, Set<PositionType> allowed, PipelineComponent component) {
 115                 this(parentShell, allowed, component, Plant3D.URIs.Builtin);
 116         }
 117
 118         public ComponentSelectionDialog(Shell parentShell, Set<PositionType> allowed, PipelineComponent component,
 119                         String libUri) {
 120                 super(parentShell);
 121                 this.allowed = allowed;
 122                 this.component = component;
 123                 filterAllowed = new HashSet<PositionType>();
 124                 insertAdjustable = component instanceof InlineComponent ? ((InlineComponent) component).isVariableLength()
 125                                 : false;
 126                 lenghtAdjustable = false;
 127                 this.libUri = libUri;
 128
 129                 usedNames = new HashSet<>();
 130
 131                 setShellStyle(getShellStyle() | SWT.RESIZE);
 132
 133                 IDialogSettings settings = Activator.getDefault().getDialogSettings();
 134                 dialogSettings = settings.getSection(DIALOG);
 135                 if (dialogSettings == null)
 136                         dialogSettings = settings.addNewSection(DIALOG);
 137
 138                 if (component.getNext() != null && component.getPrevious() != null)
 139                         insertPosition = PositionType.PREVIOUS;
 140         }
 141
 142         public void setLengthFactor(double lengthFactor) {
 143                 this.lengthFactor = lengthFactor;
 144         }
 145
 146         @Override
 147         protected IDialogSettings getDialogBoundsSettings() {
 148                 return dialogSettings;
 149         }
 150
 151         @Override
 152         protected void configureShell(Shell newShell) {
 153                 super.configureShell(newShell);
 154                 newShell.setText("Create pipeline component");
 155         }
 156
 157         public void addUsedNames(Collection<String> names) {
 158                 usedNames.addAll(names);
 159         }
 160
 161         protected List<Item> getItems(Class<?> c, String libUri) throws DatabaseException {
 162                 Session session = Simantics.getSession();
 163                 if (InlineComponent.class.equals(c)) {
 164                         return P3DUtil.getInlines(session, libUri);
 165                 } else if (TurnComponent.class.equals(c)) {
 166                         return P3DUtil.getTurns(session, libUri);
 167                 } else if (EndComponent.class.equals(c)) {
 168                         return P3DUtil.getEnds(session, libUri);
 169                 } else {
 170                         return null;
 171                 }
 172         }
 173
 174         @Override
 175         protected Control createDialogArea(Composite parent) {
 176                 resourceManager = new LocalResourceManager(JFaceResources.getResources(), parent);
 177
 178                 Composite composite = new Composite(parent, SWT.NONE);
 179                 GridLayout layout = new GridLayout(2, false);
 180                 layout.marginHeight = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_MARGIN);
 181                 layout.marginWidth = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_MARGIN);
 182                 layout.verticalSpacing = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_SPACING);
 183                 layout.horizontalSpacing = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_SPACING);
 184                 composite.setLayout(layout);
 185                 composite.setLayoutData(new GridData(GridData.FILL_BOTH));
 186                 applyDialogFont(composite);
 187
 188                 // Grid layout data for fields that grab horizontal space
 189                 final GridDataFactory horizFillData = GridDataFactory.fillDefaults().grab(true, false).align(SWT.FILL, SWT.TOP);
 190
 191                 // TODO : we need better classification than inline,turn, and end:
 192                 // * fixed length inlines
 193                 // * fixed angle turns
 194                 // * size changes (requires input for pipe run specs)
 195                 // * variable length inlines (input for length)
 196                 // * variable angle turns (input for angle)
 197                 // * ends
 198
 199                 List<Item> ends = null;
 200                 List<Item> turns = null;
 201                 List<Item> inlines = null;
 202                 try {
 203                         ends = getItems(EndComponent.class, libUri);
 204                         turns = getItems(TurnComponent.class, libUri);
 205                         inlines = getItems(InlineComponent.class, libUri);
 206                 } catch (DatabaseException e) {
 207                         Label label = new Label(composite, SWT.NONE);
 208                         label.setText("Cannot load pipeline components: " + e.getMessage());
 209                         ExceptionUtils.logError(e);
 210                         return composite;
 211                 }
 212                 ends = P3DUtil.filterUserComponents(ends);
 213                 turns = P3DUtil.filterUserComponents(turns);
 214                 inlines = P3DUtil.filterUserComponents(inlines);
 215
 216                 ExpandBar expandBar = new ExpandBar(composite, SWT.V_SCROLL);
 217
 218                 ExpandItem inlineItem = new ExpandItem(expandBar, SWT.NONE);
 219                 inlineItem.setText("Inline");
 220                 inlineViewer = new ListViewer(expandBar);
 221                 inlineViewer.setLabelProvider(new ComponentLabelProvider());
 222                 inlineViewer.setContentProvider(new ComponentContentProvider());
 223
 224                 ExpandItem turnItem = new ExpandItem(expandBar, SWT.NONE);
 225                 turnItem.setText("Turn");
 226                 turnViewer = new ListViewer(expandBar);
 227                 turnViewer.setLabelProvider(new ComponentLabelProvider());
 228                 turnViewer.setContentProvider(new ComponentContentProvider());
 229
 230                 ExpandItem endItem = new ExpandItem(expandBar, SWT.NONE);
 231                 endItem.setText("End");
 232                 endViewer = new ListViewer(expandBar);
 233                 endViewer.setLabelProvider(new ComponentLabelProvider());
 234                 endViewer.setContentProvider(new ComponentContentProvider());
 235
 236                 inlineItem.setControl(inlineViewer.getList());
 237                 turnItem.setControl(turnViewer.getList());
 238                 endItem.setControl(endViewer.getList());
 239
 240                 inlineViewer.setInput(inlines);
 241                 turnViewer.setInput(turns);
 242                 endViewer.setInput(ends);
 243
 244                 inlineItem.setHeight(inlineViewer.getList().computeSize(SWT.DEFAULT, SWT.DEFAULT).y);
 245                 turnItem.setHeight(turnViewer.getList().computeSize(SWT.DEFAULT, SWT.DEFAULT).y);
 246                 endItem.setHeight(endViewer.getList().computeSize(SWT.DEFAULT, SWT.DEFAULT).y);
 247
 248                 inlineViewer.addSelectionChangedListener(this);
 249                 turnViewer.addSelectionChangedListener(this);
 250                 endViewer.addSelectionChangedListener(this);
 251
 252                 GridDataFactory.fillDefaults().grab(true, true).align(SWT.FILL, SWT.FILL).span(2, 1).applyTo(expandBar);
 253                 GridDataFactory.fillDefaults().grab(true, true).minSize(500, 500).hint(500, 500).applyTo(composite);
 254
 255                 Label label = new Label(composite, SWT.NONE);
 256                 label.setText("Position");
 257                 Composite buttonComposite = new Composite(composite, SWT.NONE);
 258                 startButton = new Button(buttonComposite, SWT.TOGGLE);
 259                 middleButton = new Button(buttonComposite, SWT.TOGGLE);
 260                 endButton = new Button(buttonComposite, SWT.TOGGLE);
 261                 startButton.setImage(resourceManager.createImage(
 262                                 ResourceLocator.imageDescriptorFromBundle(Activator.PLUGIN_ID, "icons/insert_start.png").get()));
 263                 middleButton.setImage(resourceManager.createImage(
 264                                 ResourceLocator.imageDescriptorFromBundle(Activator.PLUGIN_ID, "icons/insert_middle.png").get()));
 265                 endButton.setImage(resourceManager.createImage(
 266                                 ResourceLocator.imageDescriptorFromBundle(Activator.PLUGIN_ID, "icons/insert_end.png").get()));
 267                 startButton.setToolTipText("Overlapping insert");
 268                 middleButton.setToolTipText("Cutting insert");
 269                 endButton.setToolTipText("Adding insert");
 270                 horizFillData.applyTo(buttonComposite);
 271                 GridLayoutFactory.fillDefaults().numColumns(3).applyTo(buttonComposite);
 272
 273                 startButton.setSelection(insertPosition == PositionType.PREVIOUS);
 274                 middleButton.setSelection(insertPosition == PositionType.SPLIT);
 275                 endButton.setSelection(insertPosition == PositionType.NEXT);
 276
 277                 startButton.setEnabled(false);
 278                 middleButton.setEnabled(false);
 279                 endButton.setEnabled(false);
 280
 281                 startButton.addSelectionListener(new SelectionAdapter() {
 282                         @Override
 283                         public void widgetSelected(SelectionEvent e) {
 284                                 updateInsertPosition(PositionType.PREVIOUS);
 285                         }
 286                 });
 287
 288                 middleButton.addSelectionListener(new SelectionAdapter() {
 289                         @Override
 290                         public void widgetSelected(SelectionEvent e) {
 291                                 updateInsertPosition(PositionType.SPLIT);
 292                         }
 293                 });
 294                 endButton.addSelectionListener(new SelectionAdapter() {
 295                         @Override
 296                         public void widgetSelected(SelectionEvent e) {
 297                                 updateInsertPosition(PositionType.NEXT);
 298                         }
 299                 });
 300
 301                 if (!hasInsertPosition()) {
 302                         label.setVisible(false);
 303                         buttonComposite.setVisible(false);
 304                 }
 305
 306                 label = new Label(composite, SWT.NONE);
 307                 label.setText("Name");
 308                 nameText = new Text(composite, SWT.SINGLE | SWT.BORDER);
 309
 310                 label = new Label(composite, SWT.NONE);
 311                 label.setText("Length");
 312                 lengthText = new Text(composite, SWT.SINGLE | SWT.BORDER);
 313                 label = new Label(composite, SWT.NONE);
 314                 label.setText("Angle");
 315                 angleText = new Text(composite, SWT.SINGLE | SWT.BORDER);
 316                 label = new Label(composite, SWT.NONE);
 317                 label.setText("Rotation angle");
 318                 rotationAngleText = new Text(composite, SWT.SINGLE | SWT.BORDER);
 319
 320                 label = new Label(composite, SWT.NONE);
 321                 label.setText("Diameter");
 322                 diameterText = new Text(composite, SWT.SINGLE | SWT.BORDER);
 323                 label = new Label(composite, SWT.NONE);
 324                 label.setText("Wall thickness");
 325                 thicknessText = new Text(composite, SWT.SINGLE | SWT.BORDER);
 326                 label = new Label(composite, SWT.NONE);
 327                 label.setText("Turn radius");
 328                 turnRadiusText = new Text(composite, SWT.SINGLE | SWT.BORDER);
 329
 330                 validationLabel = new Label(composite, SWT.NONE);
 331                 validationLabel.setText("");
 332
 333                 lengthText.setEnabled(false);
 334                 angleText.setEnabled(false);
 335                 rotationAngleText.setEnabled(false);
 336                 turnRadiusText.setEnabled(false);
 337                 diameterText.setEnabled(false);
 338                 thicknessText.setEnabled(false);
 339
 340                 nameText.addKeyListener(new KeyAdapter() {
 341                         @Override
 342                         public void keyReleased(KeyEvent e) {
 343                                 name = nameText.getText();
 344                                 validate();
 345                         }
 346                 });
 347
 348                 lengthText.addKeyListener(new KeyAdapter() {
 349                         @Override
 350                         public void keyReleased(KeyEvent e) {
 351                                 try {
 352                                         length = Double.parseDouble(lengthText.getText()) / lengthFactor;
 353                                 } catch (NumberFormatException err) {
 354                                         length = null;
 355                                 }
 356                                 validate();
 357                         }
 358                 });
 359
 360                 angleText.addKeyListener(new KeyAdapter() {
 361                         @Override
 362                         public void keyReleased(KeyEvent e) {
 363                                 try {
 364                                         angle = Double.parseDouble(angleText.getText());
 365                                 } catch (NumberFormatException err) {
 366                                         angle = null;
 367                                 }
 368                                 validate();
 369                         }
 370                 });
 371
 372                 rotationAngleText.addKeyListener(new KeyAdapter() {
 373                         @Override
 374                         public void keyReleased(KeyEvent e) {
 375                                 try {
 376                                         rotationAngle = Double.parseDouble(rotationAngleText.getText());
 377                                 } catch (NumberFormatException err) {
 378                                         rotationAngle = null;
 379                                 }
 380                                 validate();
 381                         }
 382                 });
 383
 384                 diameterText.addKeyListener(new KeyAdapter() {
 385                         @Override
 386                         public void keyReleased(KeyEvent e) {
 387                                 try {
 388                                         diameter = Double.parseDouble(diameterText.getText()) / lengthFactor;
 389                                 } catch (NumberFormatException err) {
 390                                         diameter = null;
 391                                 }
 392                                 validate();
 393                         }
 394                 });
 395
 396                 thicknessText.addKeyListener(new KeyAdapter() {
 397                         @Override
 398                         public void keyReleased(KeyEvent e) {
 399                                 try {
 400                                         thickness = Double.parseDouble(thicknessText.getText()) / lengthFactor;
 401                                 } catch (NumberFormatException err) {
 402                                         thickness = null;
 403                                 }
 404                                 validate();
 405                         }
 406                 });
 407
 408                 turnRadiusText.addKeyListener(new KeyAdapter() {
 409                         @Override
 410                         public void keyReleased(KeyEvent e) {
 411                                 try {
 412                                         turnRadius = Double.parseDouble(turnRadiusText.getText()) / lengthFactor;
 413                                 } catch (NumberFormatException err) {
 414                                         turnRadius = null;
 415                                 }
 416                                 validate();
 417                         }
 418                 });
 419
 420                 horizFillData.applyTo(nameText);
 421                 horizFillData.applyTo(lengthText);
 422                 horizFillData.applyTo(angleText);
 423                 horizFillData.applyTo(rotationAngleText);
 424                 horizFillData.applyTo(diameterText);
 425                 horizFillData.applyTo(thicknessText);
 426                 horizFillData.applyTo(turnRadiusText);
 427
 428                 GridDataFactory.fillDefaults().span(2, 1).align(SWT.END, SWT.END).grab(true, false).applyTo(validationLabel);
 429
 430                 if (!allowed.contains(PositionType.NEXT) && !allowed.contains(PositionType.PREVIOUS)) {
 431                         turnViewer.getList().setEnabled(false);
 432                         endViewer.getList().setEnabled(false);
 433                         inlineSplit = true;
 434                 }
 435
 436                 return composite;
 437         }
 438
 439         private boolean hasInsertPosition() {
 440                 return component.getNext() == null || component.getPrevious() == null;
 441         }
 442
 443         private void updateInsertPosition(PositionType type) {
 444                 if (insertPosition == type)
 445                         return;
 446                 startButton.setSelection(type == PositionType.PREVIOUS);
 447                 middleButton.setSelection(type == PositionType.SPLIT);
 448                 endButton.setSelection(type == PositionType.NEXT);
 449                 insertPosition = type;
 450         }
 451
 452         @Override
 453         public void selectionChanged(SelectionChangedEvent event) {
 454                 IStructuredSelection sel = (IStructuredSelection) event.getSelection();
 455                 Item i = (Item) sel.getFirstElement();
 456                 if (i != null) {
 457                         selected = i;
 458                         if (event.getSource() == inlineViewer) {
 459                                 turnViewer.setSelection(new StructuredSelection());
 460                                 endViewer.setSelection(new StructuredSelection());
 461                         } else if (event.getSource() == turnViewer) {
 462                                 inlineViewer.setSelection(new StructuredSelection());
 463                                 endViewer.setSelection(new StructuredSelection());
 464                         } else if (event.getSource() == endViewer) {
 465                                 inlineViewer.setSelection(new StructuredSelection());
 466                                 turnViewer.setSelection(new StructuredSelection());
 467                         }
 468
 469                         name = generateUniqueName(selected.getName());
 470                         nameText.setText(name);
 471
 472                         validate();
 473                 }
 474         }
 475
 476         private void validate() {
 477                 filterAllowed.clear();
 478                 Set<PositionType> filterAllowed = new HashSet<PositionType>();
 479                 boolean ok = true;
 480                 String msg = null;
 481
 482                 if (name.isEmpty() || usedNames.contains(name)) {
 483                         ok = false;
 484                         if (msg == null) {
 485                                 if (name.isEmpty())
 486                                         msg = "Please provide a valid name";
 487                                 else
 488                                         msg = "Name \"" + name + "\" is already in use";
 489                         }
 490                 }
 491
 492                 if (selected == null) {
 493                         ok = false;
 494                 } else if (selected.isCode()) {// TODO : instead of disabling the button, we should filter the content.
 495                         ok = false;
 496                 } else {
 497                         lenghtAdjustable = ((selected.getType() == Type.INLINE)
 498                                         && (selected.isVariable() || selected.isModifiable()));
 499
 500                         if (!hasInsertPosition()) {
 501                                 // We are inserting to a fully connected variable length component
 502                                 // only allow insertion within the component
 503                                 startButton.setEnabled(false);
 504                                 middleButton.setEnabled(false);
 505                                 endButton.setEnabled(false);
 506                                 updateInsertPosition(PositionType.PREVIOUS);
 507                         } else if (insertAdjustable) {
 508                                 switch (selected.getType()) {
 509                                 case END:
 510                                         startButton.setEnabled(false);
 511                                         middleButton.setEnabled(false);
 512                                         endButton.setEnabled(true);
 513                                         updateInsertPosition(PositionType.NEXT);
 514                                         break;
 515                                 case INLINE:
 516                                         if (!selected.isVariable()) {
 517                                                 startButton.setEnabled(true);
 518                                                 middleButton.setEnabled(true);
 519                                                 endButton.setEnabled(true);
 520                                         } else {
 521                                                 startButton.setEnabled(false);
 522                                                 middleButton.setEnabled(false);
 523                                                 endButton.setEnabled(true);
 524                                                 updateInsertPosition(PositionType.NEXT);
 525                                         }
 526                                         break;
 527                                 case NOZZLE:
 528                                         startButton.setEnabled(false);
 529                                         middleButton.setEnabled(false);
 530                                         endButton.setEnabled(true);
 531                                         updateInsertPosition(PositionType.NEXT);
 532                                         break;
 533                                 case TURN:
 534                                         startButton.setEnabled(false);
 535                                         middleButton.setEnabled(true);
 536                                         endButton.setEnabled(true);
 537                                         if (insertPosition == PositionType.PREVIOUS)
 538                                                 updateInsertPosition(PositionType.NEXT);
 539                                         break;
 540                                 case EQUIPMENT:
 541                                         throw new RuntimeException("Expected component, got equipment " + selected);
 542                                 }
 543                         } else if (lenghtAdjustable) {
 544                                 if (component instanceof InlineComponent) {
 545                                         startButton.setEnabled(true);
 546                                         middleButton.setEnabled(true);
 547                                         endButton.setEnabled(true);
 548                                 } else if (component instanceof TurnComponent) {
 549                                         startButton.setEnabled(false);
 550                                         middleButton.setEnabled(true);
 551                                         endButton.setEnabled(true);
 552                                         if (insertPosition == PositionType.PREVIOUS)
 553                                                 updateInsertPosition(PositionType.NEXT);
 554                                 } else if (component instanceof EndComponent || component instanceof Nozzle) {
 555                                         startButton.setEnabled(false);
 556                                         middleButton.setEnabled(false);
 557                                         endButton.setEnabled(true);
 558                                         updateInsertPosition(PositionType.NEXT);
 559                                 }
 560                         } else {
 561                                 startButton.setEnabled(false);
 562                                 middleButton.setEnabled(false);
 563                                 endButton.setEnabled(true);
 564                         }
 565                         if (selected.isVariable() || selected.isModifiable()) {
 566                                 if (selected.getType() == Type.INLINE) {
 567                                         filterAllowed.add(PositionType.NEXT);
 568                                         filterAllowed.add(PositionType.PREVIOUS);
 569                                         if (inlineSplit && selected.isVariable()) {
 570                                                 lengthText.setEnabled(false);
 571                                                 angleText.setEnabled(false);
 572                                                 rotationAngleText.setEnabled(selected.isRotated());
 573                                                 ok = false;
 574                                                 if (msg == null) msg = "Cannot split a straight pipe with a straight pipe";
 575                                         } else {
 576                                                 lengthText.setEnabled(true);
 577                                                 angleText.setEnabled(false);
 578                                                 rotationAngleText.setEnabled(selected.isRotated());
 579                                                 if (length == null || length <= 0.0) {
 580                                                         ok = false;
 581                                                         if (msg == null) msg = "Please provide a valid length";
 582                                                 }
 583                                         }
 584                                 } else if (selected.getType() == Type.TURN) {
 585                                         filterAllowed.add(PositionType.NEXT);
 586                                         filterAllowed.add(PositionType.PREVIOUS);
 587                                         lengthText.setEnabled(false);
 588                                         angleText.setEnabled(true);
 589                                         rotationAngleText.setEnabled(true);
 590                                         if (angle == null) {
 591                                                 ok = false;
 592                                                 if (msg == null) msg = "Please provide a turn angle";
 593                                         }
 594                                 } else {
 595                                         // this should not happen, since end components should not have variable, or
 596                                         // modifiable flag.
 597                                         lengthText.setEnabled(false);
 598                                         angleText.setEnabled(false);
 599                                         rotationAngleText.setEnabled(false);
 600
 601                                 }
 602                         } else {
 603                                 lengthText.setEnabled(false);
 604                                 angleText.setEnabled(false);
 605                                 rotationAngleText.setEnabled(selected.getType() == Type.TURN || selected.isRotated());
 606                         }
 607
 608                         if (selected.isSizeChange()) {
 609                                 turnRadiusText.setEnabled(true);
 610                                 diameterText.setEnabled(true);
 611                                 thicknessText.setEnabled(true);
 612                                 if (diameter == null || diameter <= 0.0) {
 613                                         ok = false;
 614                                         if (msg == null) msg = "Please provide a valid diameter";
 615                                 }
 616                                 if (turnRadius == null || diameter != null && turnRadius < diameter / 2) {
 617                                         ok = false;
 618                                         if (msg == null) msg = "Please provide a valid turn radius";
 619                                 }
 620                                 if (thickness == null || thickness < 0.0 || diameter != null && thickness >= diameter / 2) {
 621                                         ok = false;
 622                                         if (msg == null) msg = "Please provide a valid wall thickness";
 623                                 }
 624                         } else {
 625                                 turnRadiusText.setEnabled(false);
 626                                 diameterText.setEnabled(false);
 627                         }
 628
 629                         if (!selected.isVariable()) {
 630                                 switch (selected.getType()) {
 631                                 case END:
 632                                         filterAllowed.add(PositionType.NEXT);
 633                                         filterAllowed.add(PositionType.PREVIOUS);
 634                                         break;
 635                                 case NOZZLE:
 636                                 case EQUIPMENT:
 637                                         break;
 638                                 case INLINE:
 639                                         filterAllowed.add(PositionType.NEXT);
 640                                         filterAllowed.add(PositionType.PREVIOUS);
 641                                         filterAllowed.add(PositionType.SPLIT);
 642                                 case TURN:
 643                                         filterAllowed.add(PositionType.NEXT);
 644                                         filterAllowed.add(PositionType.PREVIOUS);
 645                                 }
 646                         }
 647                 }
 648                 for (PositionType t : filterAllowed) {
 649                         if (allowed.contains(t))
 650                                 this.filterAllowed.add(t);
 651                 }
 652
 653                 validationLabel.setText(msg != null ? msg : "");
 654                 validationLabel.requestLayout();
 655
 656                 getButton(OK).setEnabled(ok);
 657         }
 658
 659         private String generateUniqueName(String name) {
 660                 int i = 1;
 661                 String newName;
 662                 while (usedNames.contains((newName = name + "_" + i)))
 663                         i++;
 664                 return newName;
 665         }
 666
 667         public Item getSelected() {
 668                 return selected;
 669         }
 670
 671         public String getName() {
 672                 return name;
 673         }
 674
 675         public Double getAngle() {
 676                 return angle;
 677         }
 678
 679         public Double getLength() {
 680                 return length;
 681         }
 682
 683         public Double getRotationAngle() {
 684                 return rotationAngle;
 685         }
 686
 687         public Double getDiameter() {
 688                 return diameter;
 689         }
 690
 691         public Double getTurnRadius() {
 692                 return turnRadius;
 693         }
 694
 695         public Set<PositionType> filterAllowed() {
 696                 return filterAllowed;
 697         }
 698
 699         public PositionType getInsertPosition() {
 700                 return insertPosition;
 701         }
 702
 703         public boolean isInsertAdjustable() {
 704                 return insertAdjustable;
 705         }
 706
 707         public boolean isLenghtAdjustable() {
 708                 return lenghtAdjustable;
 709         }
 710
 711         public Double getThickness() {
 712                 return thickness;
 713         }
 714
 715 }