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

   1 package org.simantics.plant3d.dialog;
   2
   3 import java.util.HashSet;
   4 import java.util.List;
   5 import java.util.Set;
   6
   7 import org.eclipse.jface.dialogs.Dialog;
   8 import org.eclipse.jface.dialogs.IDialogConstants;
   9 import org.eclipse.jface.layout.GridDataFactory;
  10 import org.eclipse.jface.viewers.ISelectionChangedListener;
  11 import org.eclipse.jface.viewers.IStructuredSelection;
  12 import org.eclipse.jface.viewers.ListViewer;
  13 import org.eclipse.jface.viewers.SelectionChangedEvent;
  14 import org.eclipse.swt.SWT;
  15 import org.eclipse.swt.events.KeyAdapter;
  16 import org.eclipse.swt.events.KeyEvent;
  17 import org.eclipse.swt.layout.GridData;
  18 import org.eclipse.swt.layout.GridLayout;
  19 import org.eclipse.swt.widgets.Composite;
  20 import org.eclipse.swt.widgets.Control;
  21 import org.eclipse.swt.widgets.ExpandBar;
  22 import org.eclipse.swt.widgets.ExpandItem;
  23 import org.eclipse.swt.widgets.Label;
  24 import org.eclipse.swt.widgets.Shell;
  25 import org.eclipse.swt.widgets.Text;
  26 import org.simantics.db.exception.DatabaseException;
  27 import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint.PositionType;
  28 import org.simantics.plant3d.utils.Item;
  29 import org.simantics.plant3d.utils.Item.Type;
  30 import org.simantics.plant3d.utils.P3DUtil;
  31 import org.simantics.utils.ui.ExceptionUtils;
  32
  33 public class ComponentSelectionDialog extends Dialog implements ISelectionChangedListener{
  34
  35         private Item selected;
  36         private Set<PositionType> allowed;
  37         private Set<PositionType> filterAllowed;
  38         private Double angle;
  39         private Double length;
  40
  41         private Text lengthText;
  42         private Text angleText;
  43
  44         private Double diameter;
  45         private Double turnRadius;
  46
  47         private Text diameterText;
  48         private Text turnRadiusText;
  49
  50         private boolean inlineSplit = false;
  51
  52
  53         public ComponentSelectionDialog(Shell parentShell, Set<PositionType> allowed) {
  54                 super(parentShell);
  55                 this.allowed = allowed;
  56                 filterAllowed = new HashSet<PositionType>();
  57         }
  58
  59         @Override
  60         protected Control createDialogArea(Composite parent) {
  61                 Composite composite = new Composite(parent, SWT.NONE);
  62                 GridLayout layout = new GridLayout(2,false);
  63                 layout.marginHeight = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_MARGIN);
  64                 layout.marginWidth = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_MARGIN);
  65                 layout.verticalSpacing = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_SPACING);
  66                 layout.horizontalSpacing = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_SPACING);
  67                 composite.setLayout(layout);
  68                 composite.setLayoutData(new GridData(GridData.FILL_BOTH));
  69                 applyDialogFont(composite);
  70
  71                 // TODO : we need better classification than inline,turn, and end:
  72                 // * fixed length inlines
  73                 // * fixed angle turns
  74                 // * size changes (requires input for pipe run specs)
  75                 // * variable length inlines (input for length)
  76                 // * variable angle turns (input for angle)
  77                 // * ends
  78
  79                 List<Item> ends = null;
  80                 List<Item> turns = null;
  81                 List<Item> inlines = null;
  82                 try {
  83                         ends = P3DUtil.getEnds();
  84                         turns= P3DUtil.getTurns();
  85                         inlines = P3DUtil.getInlines();
  86                 } catch (DatabaseException e) {
  87                         Label label = new Label(composite, SWT.NONE);
  88                         label.setText("Cannot load pipeline components: " + e.getMessage());
  89                         ExceptionUtils.logError(e);
  90                         return composite;
  91                 }
  92
  93                 ExpandBar expandBar = new ExpandBar(composite, SWT.NONE);
  94
  95
  96                 ExpandItem inlineItem = new ExpandItem(expandBar, SWT.NONE);
  97                 inlineItem.setText("Inline");
  98                 ListViewer inlineViewer = new ListViewer(expandBar);
  99                 inlineViewer.setLabelProvider(new ComponentLabelProvider());
 100                 inlineViewer.setContentProvider(new ComponentContentProvider());
 101
 102                 ExpandItem turnItem = new ExpandItem(expandBar, SWT.NONE);
 103                 turnItem.setText("Turn");
 104                 ListViewer turnViewer = new ListViewer(expandBar);
 105                 turnViewer.setLabelProvider(new ComponentLabelProvider());
 106                 turnViewer.setContentProvider(new ComponentContentProvider());
 107
 108                 ExpandItem endItem = new ExpandItem(expandBar, SWT.NONE);
 109                 endItem.setText("End");
 110                 ListViewer endViewer = new ListViewer(expandBar);
 111                 endViewer.setLabelProvider(new ComponentLabelProvider());
 112                 endViewer.setContentProvider(new ComponentContentProvider());
 113
 114
 115                 inlineItem.setControl(inlineViewer.getList());
 116                 turnItem.setControl(turnViewer.getList());
 117                 endItem.setControl(endViewer.getList());
 118
 119                 inlineViewer.setInput(inlines);
 120                 turnViewer.setInput(turns);
 121                 endViewer.setInput(ends);
 122
 123                 inlineItem.setHeight(inlineViewer.getList().computeSize(SWT.DEFAULT, SWT.DEFAULT).y);
 124                 turnItem.setHeight(turnViewer.getList().computeSize(SWT.DEFAULT, SWT.DEFAULT).y);
 125                 endItem.setHeight(endViewer.getList().computeSize(SWT.DEFAULT, SWT.DEFAULT).y);
 126
 127                 inlineViewer.addSelectionChangedListener(this);
 128                 turnViewer.addSelectionChangedListener(this);
 129                 endViewer.addSelectionChangedListener(this);
 130
 131                 GridDataFactory.fillDefaults().grab(true, true).align(SWT.FILL, SWT.FILL).span(2, 1).applyTo(expandBar);
 132                 GridDataFactory.fillDefaults().minSize(500, 500).hint(500, 500).applyTo(composite);
 133
 134
 135                 Label label = new Label(composite, SWT.NONE);
 136                 label.setText("Length");
 137                 lengthText = new Text(composite, SWT.SINGLE|SWT.BORDER);
 138                 label = new Label(composite, SWT.NONE);
 139                 label.setText("Angle");
 140                 angleText = new Text(composite, SWT.SINGLE|SWT.BORDER);
 141
 142                 label = new Label(composite, SWT.NONE);
 143                 label.setText("Diameter");
 144                 diameterText = new Text(composite, SWT.SINGLE|SWT.BORDER);
 145                 label = new Label(composite, SWT.NONE);
 146                 label.setText("Turn Radius");
 147                 turnRadiusText = new Text(composite, SWT.SINGLE|SWT.BORDER);
 148
 149                 lengthText.setEnabled(false);
 150                 angleText.setEnabled(false);
 151                 turnRadiusText.setEnabled(false);
 152                 diameterText.setEnabled(false);
 153
 154                 lengthText.addKeyListener(new KeyAdapter() {
 155                         @Override
 156                         public void keyReleased(KeyEvent e) {
 157                                 try {
 158                                         length = Double.parseDouble(lengthText.getText());
 159                                 } catch (NumberFormatException err) {
 160                                         length = null;
 161                                 }
 162                                 validate();
 163                         }
 164                 });
 165
 166                 angleText.addKeyListener(new KeyAdapter() {
 167                         @Override
 168                         public void keyReleased(KeyEvent e) {
 169                                 try {
 170                                         angle = Double.parseDouble(angleText.getText());
 171                                 } catch (NumberFormatException err) {
 172                                         angle = null;
 173                                 }
 174                                 validate();
 175                         }
 176                 });
 177
 178                 diameterText.addKeyListener(new KeyAdapter() {
 179                         @Override
 180                         public void keyReleased(KeyEvent e) {
 181                                 try {
 182                                         diameter = Double.parseDouble(diameterText.getText());
 183                                 } catch (NumberFormatException err) {
 184                                         diameter = null;
 185                                 }
 186                                 validate();
 187                         }
 188                 });
 189
 190                 turnRadiusText.addKeyListener(new KeyAdapter() {
 191                         @Override
 192                         public void keyReleased(KeyEvent e) {
 193                                 try {
 194                                         turnRadius = Double.parseDouble(turnRadiusText.getText());
 195                                 } catch (NumberFormatException err) {
 196                                         turnRadius = null;
 197                                 }
 198                                 validate();
 199                         }
 200                 });
 201
 202                 GridDataFactory.fillDefaults().grab(true, false).align(SWT.FILL, SWT.TOP).applyTo(lengthText);
 203                 GridDataFactory.fillDefaults().grab(true, false).align(SWT.FILL, SWT.TOP).applyTo(angleText);
 204                 GridDataFactory.fillDefaults().grab(true, false).align(SWT.FILL, SWT.TOP).applyTo(diameterText);
 205                 GridDataFactory.fillDefaults().grab(true, false).align(SWT.FILL, SWT.TOP).applyTo(turnRadiusText);
 206
 207                 if (!allowed.contains(PositionType.NEXT) && !allowed.contains(PositionType.PREVIOUS)) {
 208                         turnViewer.getList().setEnabled(false);
 209                         endViewer.getList().setEnabled(false);
 210                         inlineSplit = true;
 211                 }
 212
 213                 return composite;
 214         }
 215
 216
 217         @Override
 218         public void selectionChanged(SelectionChangedEvent event) {
 219                 IStructuredSelection sel = (IStructuredSelection)event.getSelection();
 220                 selected = (Item)sel.getFirstElement();
 221                 validate();
 222         }
 223
 224         private void validate() {
 225                 filterAllowed.clear();
 226                 Set<PositionType> filterAllowed = new HashSet<PositionType>();
 227                 boolean ok = true;
 228                 if (selected == null) {
 229                         ok = false;
 230                 } else if (selected.isCode()) {// TODO : instead of disabling the button, we should filter the content.
 231                         ok = false;
 232                 } else {
 233                         if (selected.isVariable()) {
 234                                 if (selected.getType() == Type.INLINE) {
 235                                         filterAllowed.add(PositionType.NEXT);
 236                                         filterAllowed.add(PositionType.PREVIOUS);
 237                                         if (inlineSplit) {
 238                                                 lengthText.setEnabled(false);
 239                                                 angleText.setEnabled(false);
 240                                                 ok = false;
 241
 242                                         } else {
 243                                                 lengthText.setEnabled(true);
 244                                                 angleText.setEnabled(false);
 245                                                 if (length == null)
 246                                                         ok = false;
 247                                         }
 248                                 } else if (selected.getType() == Type.TURN) {
 249                                         filterAllowed.add(PositionType.NEXT);
 250                                         filterAllowed.add(PositionType.PREVIOUS);
 251                                         lengthText.setEnabled(false);
 252                                         angleText.setEnabled(true);
 253                                         if (angle == null)
 254                                                 ok = false;
 255                                 } else {
 256                                         // this should not happen
 257                                         lengthText.setEnabled(false);
 258                                         angleText.setEnabled(false);
 259                                 }
 260                         } else {
 261                                 lengthText.setEnabled(false);
 262                                 angleText.setEnabled(false);
 263                         }
 264
 265                         if (selected.isSizeChange()) {
 266                                 filterAllowed.add(PositionType.NEXT);
 267                                 filterAllowed.add(PositionType.PREVIOUS);
 268                                 if (inlineSplit) {
 269                                         turnRadiusText.setEnabled(false);
 270                                         diameterText.setEnabled(false);
 271                                         ok = false;
 272                                 } else {
 273                                         turnRadiusText.setEnabled(true);
 274                                         diameterText.setEnabled(true);
 275                                         if (diameter == null || turnRadius == null)
 276                                                 ok = false;
 277                                 }
 278
 279                         } else {
 280                                 turnRadiusText.setEnabled(false);
 281                                 diameterText.setEnabled(false);
 282                         }
 283
 284                         if (!selected.isSizeChange() && !selected.isVariable()) {
 285                                 switch (selected.getType()) {
 286                                         case END:
 287                                                 filterAllowed.add(PositionType.NEXT);
 288                                                 filterAllowed.add(PositionType.PREVIOUS);
 289                                                 break;
 290                                         case NOZZLE:
 291                                         case EQUIPMENT:
 292                                                 break;
 293                                         case INLINE:
 294                                                 filterAllowed.add(PositionType.NEXT);
 295                                                 filterAllowed.add(PositionType.PREVIOUS);
 296                                                 filterAllowed.add(PositionType.SPLIT);
 297                                         case TURN:
 298                                                 filterAllowed.add(PositionType.NEXT);
 299                                                 filterAllowed.add(PositionType.PREVIOUS);
 300                                 }
 301                         }
 302                 }
 303                 for (PositionType t : filterAllowed) {
 304                         if (allowed.contains(t))
 305                                 this.filterAllowed.add(t);
 306                 }
 307
 308                 getButton(OK).setEnabled(ok);
 309         }
 310
 311         public Item getSelected() {
 312                 return selected;
 313         }
 314
 315         public Double getAngle() {
 316                 return angle;
 317         }
 318
 319         public Double getLength() {
 320                 return length;
 321         }
 322
 323         public Double getDiameter() {
 324                 return diameter;
 325         }
 326
 327         public Double getTurnRadius() {
 328                 return turnRadius;
 329         }
 330
 331         public Set<PositionType> filterAllowed() {
 332                 return filterAllowed;
 333         }
 334
 335
 336 }