org.simantics.district.imports.ui/src/org/simantics/district/imports/ui/CSVImportWizardPage.java

   1 package org.simantics.district.imports.ui;
   2
   3 import java.io.IOException;
   4 import java.util.HashMap;
   5 import java.util.List;
   6 import java.util.Map;
   7 import java.util.Map.Entry;
   8 import java.util.Set;
   9
  10 import org.apache.commons.csv.CSVRecord;
  11 import org.eclipse.jface.dialogs.IPageChangeProvider;
  12 import org.eclipse.jface.dialogs.IPageChangedListener;
  13 import org.eclipse.jface.dialogs.PageChangedEvent;
  14 import org.eclipse.jface.layout.GridDataFactory;
  15 import org.eclipse.jface.layout.TableColumnLayout;
  16 import org.eclipse.jface.viewers.ColumnWeightData;
  17 import org.eclipse.jface.wizard.IWizardContainer;
  18 import org.eclipse.jface.wizard.WizardPage;
  19 import org.eclipse.swt.SWT;
  20 import org.eclipse.swt.events.ModifyEvent;
  21 import org.eclipse.swt.events.ModifyListener;
  22 import org.eclipse.swt.events.SelectionAdapter;
  23 import org.eclipse.swt.events.SelectionEvent;
  24 import org.eclipse.swt.events.SelectionListener;
  25 import org.eclipse.swt.layout.GridLayout;
  26 import org.eclipse.swt.widgets.Button;
  27 import org.eclipse.swt.widgets.Combo;
  28 import org.eclipse.swt.widgets.Composite;
  29 import org.eclipse.swt.widgets.Group;
  30 import org.eclipse.swt.widgets.Label;
  31 import org.eclipse.swt.widgets.Table;
  32 import org.eclipse.swt.widgets.TableColumn;
  33 import org.eclipse.swt.widgets.TableItem;
  34 import org.eclipse.swt.widgets.Text;
  35 import org.geotools.referencing.CRS;
  36 import org.simantics.district.imports.CSVImportModel;
  37 import org.simantics.district.imports.ui.controls.DynamicComboFieldEditor;
  38
  39 public class CSVImportWizardPage extends WizardPage {
  40
  41     private CSVImportModel model;
  42
  43     private Map<Integer, String> headerIndexAndValues = new HashMap<>();
  44
  45     private Table headerTable;
  46 //    private Button firstAsHeader;
  47
  48     private Combo delimiterCombo;
  49     private TableColumnLayout tableColumnLayout;
  50     private Composite tableComposite;
  51 //    private FileSelectionWidget wktFileSelection;
  52
  53     // Common for vertex and edge
  54     private DynamicComboFieldEditor componentMappingSelector;
  55     private DynamicComboFieldEditor idSelector;
  56
  57     // For vertex import
  58     private DynamicComboFieldEditor xCoordSelector;
  59     private DynamicComboFieldEditor yCoordSelector;
  60     private DynamicComboFieldEditor zValueSelector;
  61     private DynamicComboFieldEditor altElevationValueSelector;
  62
  63     private DynamicComboFieldEditor supplyTempValueSelector;
  64     private DynamicComboFieldEditor returnTempValueSelector;
  65     private DynamicComboFieldEditor supplyPressureValueSelector;
  66     private DynamicComboFieldEditor returnPressureValueSelector;
  67     private DynamicComboFieldEditor dpSelector;
  68     private DynamicComboFieldEditor dtSelector;
  69     private DynamicComboFieldEditor heatPowerSelector;
  70     private DynamicComboFieldEditor peakPowerSelector;
  71     private DynamicComboFieldEditor nominalHeadMSelector;
  72     private DynamicComboFieldEditor nominalHeadBSelector;
  73     private DynamicComboFieldEditor nominalFlowSelector;
  74     private DynamicComboFieldEditor maximumHeadMSelector;
  75     private DynamicComboFieldEditor heatLoadDsSelector;
  76     private DynamicComboFieldEditor massFlowSelector;
  77     private DynamicComboFieldEditor volFlowSelector;
  78     private DynamicComboFieldEditor velocitySelector;
  79     private DynamicComboFieldEditor flowAreaSelector;
  80     private DynamicComboFieldEditor nominalPressureLossSelector;
  81     private DynamicComboFieldEditor valvePositionSelector;
  82     private DynamicComboFieldEditor addressSelector;
  83     private DynamicComboFieldEditor lengthSelector;
  84
  85     // For edge import
  86     private DynamicComboFieldEditor startXCoordSelector;
  87     private DynamicComboFieldEditor startYCoordSelector;
  88     private DynamicComboFieldEditor startZValueSelector;
  89     private DynamicComboFieldEditor endXCoordSelector;
  90     private DynamicComboFieldEditor endYCoordSelector;
  91     private DynamicComboFieldEditor endZValueSelector;
  92     private DynamicComboFieldEditor detailedGeometrySelector;
  93
  94     private Text edgeConnectionPadding;
  95
  96     private DynamicComboFieldEditor outerDiameterSelector;
  97     private DynamicComboFieldEditor diameterSelector;
  98     private DynamicComboFieldEditor nominalMassFlowSelector;
  99
 100     private Group indexMappingGroup;
 101
 102     private Composite composite;
 103
 104     private Button isVertexImport;
 105
 106     private Combo sourceCRSCombo;
 107
 108     private DynamicComboFieldEditor edgeFlowAreaSelector;
 109
 110     private DynamicComboFieldEditor kReturnSelector;
 111
 112     private DynamicComboFieldEditor kSupplySelector;
 113
 114     private DynamicComboFieldEditor tGroundSelector;
 115
 116     protected CSVImportWizardPage(CSVImportModel model) {
 117         super("Import CSV Data");
 118         this.model = model;
 119         setMessage("Select column index mappings");
 120     }
 121
 122     @Override
 123     public void createControl(Composite parent) {
 124         composite = new Composite(parent, SWT.NONE);
 125         composite.setLayout(new GridLayout(1, false));
 126         GridDataFactory.fillDefaults().grab(true, true).align(SWT.FILL, SWT.FILL).applyTo(composite);
 127
 128         Label label = new Label(composite, SWT.NONE);
 129         label.setText("Select delimiter");
 130
 131         delimiterCombo = new Combo(composite, SWT.DROP_DOWN | SWT.READ_ONLY);
 132         delimiterCombo.setToolTipText("Select the delimiter that is used to separate elements in the CSV file");
 133         String[] formats = model.getDelimiterFormats();
 134         delimiterCombo.setItems(formats);
 135         if (formats.length > 0)
 136             delimiterCombo.select(0);
 137         delimiterCombo.addSelectionListener(new SelectionListener() {
 138
 139             @Override
 140             public void widgetSelected(SelectionEvent e) {
 141                 model.setDelimiterByLabel(delimiterCombo.getItem(delimiterCombo.getSelectionIndex()));
 142                 updateHeaders();
 143                 updateCombos();
 144             }
 145
 146             @Override
 147             public void widgetDefaultSelected(SelectionEvent e) {
 148                 widgetSelected(e);
 149             }
 150         });
 151
 152 //        firstAsHeader = new Button(composite, SWT.CHECK);
 153 //        firstAsHeader.setText("Read first row as header");
 154 //        firstAsHeader.setSelection(model.getReadFirstAsHeader());
 155 //        firstAsHeader.addSelectionListener(new SelectionListener() {
 156 //
 157 //            @Override
 158 //            public void widgetSelected(SelectionEvent e) {
 159 //                model.setReadFirstAsHeader(firstAsHeader.getSelection());
 160 //                updateHeaders();
 161 //                updateCombos();
 162 //            }
 163 //
 164 //            @Override
 165 //            public void widgetDefaultSelected(SelectionEvent e) {
 166 //                widgetSelected(e);
 167 //            }
 168 //        });
 169
 170         tableComposite = new Composite(composite, SWT.BORDER);
 171         tableColumnLayout = new TableColumnLayout();
 172         tableComposite.setLayout(tableColumnLayout);
 173
 174         label = new Label(composite, SWT.NONE);
 175         label.setText("Select source Coordinate Reference System");
 176
 177         sourceCRSCombo = new Combo(composite, SWT.NONE);
 178         sourceCRSCombo.setToolTipText("Select the coordinate reference system that is used in the source material for possible transformation to target coordinate reference system (EPSG:4326)");
 179         Set<String> codes = CRS.getSupportedCodes("EPSG");
 180         sourceCRSCombo.setItems(codes.toArray(new String[codes.size()]));
 181         sourceCRSCombo.addSelectionListener(new SelectionAdapter() {
 182
 183             @Override
 184             public void widgetSelected(SelectionEvent e) {
 185                 String current = sourceCRSCombo.getItem(sourceCRSCombo.getSelectionIndex());
 186                 model.setSourceCRS("EPSG:" + current);
 187             }
 188         });
 189
 190         sourceCRSCombo.addModifyListener(new ModifyListener() {
 191
 192             @Override
 193             public void modifyText(ModifyEvent e) {
 194                 String currentText = sourceCRSCombo.getText();
 195                 if (codes.contains(currentText)) {
 196                     // Select this
 197                     String[] items = sourceCRSCombo.getItems();
 198                     int i;
 199                     for (i = 0; i < items.length; i++) {
 200                         String item = items[i];
 201                         if (currentText.equals(item)) {
 202                             break;
 203                         }
 204                     }
 205                     if (i != 0) {
 206                         sourceCRSCombo.select(i);
 207                         model.setSourceCRS("EPSG:" + currentText);
 208                     } else {
 209                         System.err.println("this should not happen");
 210                     }
 211                 }
 212             }
 213         });
 214
 215 //        wktFileSelection = new FileSelectionWidget(composite, "WKT file", SWT.OPEN);
 216 //        wktFileSelection.addListener(new FileSelectionListener() {
 217 //
 218 //            @Override
 219 //            public void fileSelected(FileOrDirectorySelectionWidget source, String[] filename) {
 220 //                String[] selection = wktFileSelection.getFilename();
 221 //                if (selection != null && selection.length > 0) {
 222 //                    Path wktFile = Paths.get(selection[0]);
 223 //                    if (!Files.exists(wktFile)) {
 224 //                        setErrorMessage("File " + wktFile.toAbsolutePath() + " does not exist");
 225 //                    } else {
 226 //                        model.setWKTFile(wktFile);
 227 //                        validatePageComplete();
 228 //                    }
 229 //                }
 230 //            }
 231 //        });
 232
 233         isVertexImport = new Button(composite, SWT.CHECK);
 234         isVertexImport.setText("File contains vertices");
 235         isVertexImport.setToolTipText("Enable this if the file contains vertices, i.e. points");
 236         isVertexImport.setSelection(model.isVertexImport());
 237         isVertexImport.addSelectionListener(new SelectionListener() {
 238
 239             @Override
 240             public void widgetSelected(SelectionEvent e) {
 241                 model.setVertexImport(isVertexImport.getSelection());
 242                 updateControls(false);
 243             }
 244
 245             @Override
 246             public void widgetDefaultSelected(SelectionEvent e) {
 247                 widgetSelected(e);
 248             }
 249         });
 250
 251         updateControls(true);
 252         updateHeaders();
 253         setControl(composite);
 254
 255         final IWizardContainer container = getContainer();
 256
 257         if (container instanceof IPageChangeProvider) {
 258             ((IPageChangeProvider) container).addPageChangedListener(new IPageChangedListener() {
 259
 260                 @Override
 261                 public void pageChanged(PageChangedEvent event) {
 262                     if (isCurrentPage())
 263                         CSVImportWizardPage.this.updateControls(false);
 264                 }
 265             });
 266         }
 267
 268         validatePageComplete();
 269     }
 270
 271     private void updateControls(boolean initial) {
 272         createIndexMappingGroup();
 273         updateCombos();
 274         if (!initial)
 275             composite.layout(true, true);
 276     }
 277
 278     private void createIndexMappingGroup() {
 279         if (indexMappingGroup != null)
 280             indexMappingGroup.dispose();
 281
 282         indexMappingGroup = new Group(composite, SWT.NONE);
 283         indexMappingGroup.setText("Column index mapping");
 284         GridDataFactory.fillDefaults().grab(true, false).span(2, 1).applyTo(indexMappingGroup);
 285
 286         if (model.isVertexImport())
 287             createVertexIndexMappingField(indexMappingGroup);
 288         else
 289             createEdgeIndexMappingField(indexMappingGroup);
 290
 291         createCommonIndexMappingField(indexMappingGroup);
 292
 293         if (!model.isVertexImport()) {
 294             Label label = new Label(indexMappingGroup, SWT.NONE);
 295             label.setText("Connection point padding");
 296             GridDataFactory.fillDefaults().applyTo(label);
 297             edgeConnectionPadding = new Text(indexMappingGroup, SWT.BORDER);
 298             GridDataFactory.fillDefaults().applyTo(edgeConnectionPadding);
 299             edgeConnectionPadding.setText("0.0001"); // default
 300             edgeConnectionPadding.addModifyListener(new ModifyListener() {
 301
 302                 @Override
 303                 public void modifyText(ModifyEvent e) {
 304                     try {
 305                         double padding = Double.parseDouble(edgeConnectionPadding.getText());
 306                         model.setEdgePadding(padding);
 307                     } catch (NumberFormatException ee) {
 308                         // ignore
 309                     }
 310                 }
 311             });
 312         }
 313     }
 314
 315     private void createCommonIndexMappingField(Group parent) {
 316
 317         componentMappingSelector = new DynamicComboFieldEditor("componentMapping", "Apros component mapping", parent);
 318         componentMappingSelector.addComboListener(new SelectionListener() {
 319
 320             @Override
 321             public void widgetSelected(SelectionEvent e) {
 322                 widgetDefaultSelected(e);
 323             }
 324
 325             @Override
 326             public void widgetDefaultSelected(SelectionEvent e) {
 327                 model.setComponentMappingIndex(Integer.parseInt(componentMappingSelector.getValue()));
 328                 validatePageComplete();
 329             }
 330         });
 331
 332         idSelector = new DynamicComboFieldEditor("id", "ID", parent);
 333         idSelector.addComboListener(new SelectionListener() {
 334
 335             @Override
 336             public void widgetSelected(SelectionEvent e) {
 337                 widgetDefaultSelected(e);
 338             }
 339
 340             @Override
 341             public void widgetDefaultSelected(SelectionEvent e) {
 342                 model.setIdIndex(Integer.parseInt(idSelector.getValue()));
 343                 validatePageComplete();
 344             }
 345         });
 346
 347     }
 348
 349     private void createVertexIndexMappingField(Group parent) {
 350         xCoordSelector = new DynamicComboFieldEditor("xCoord", "X Coordinate", parent);
 351         xCoordSelector.addComboListener(new SelectionListener() {
 352
 353             @Override
 354             public void widgetSelected(SelectionEvent e) {
 355                 widgetDefaultSelected(e);
 356             }
 357
 358             @Override
 359             public void widgetDefaultSelected(SelectionEvent e) {
 360                 model.setXCoordIndex(Integer.parseInt(xCoordSelector.getValue()));
 361                 validatePageComplete();
 362             }
 363         });
 364
 365         yCoordSelector = new DynamicComboFieldEditor("yCoord", "Y Coordinate", parent);
 366         yCoordSelector.addComboListener(new SelectionListener() {
 367
 368             @Override
 369             public void widgetSelected(SelectionEvent e) {
 370                 widgetDefaultSelected(e);
 371             }
 372
 373             @Override
 374             public void widgetDefaultSelected(SelectionEvent e) {
 375                 model.setYCoordIndex(Integer.parseInt(yCoordSelector.getValue()));
 376                 validatePageComplete();
 377             }
 378         });
 379         zValueSelector = new DynamicComboFieldEditor("zValue", "Z Value", parent);
 380         zValueSelector.addComboListener(new SelectionListener() {
 381
 382             @Override
 383             public void widgetSelected(SelectionEvent e) {
 384                 widgetDefaultSelected(e);
 385             }
 386
 387             @Override
 388             public void widgetDefaultSelected(SelectionEvent e) {
 389                 model.setZCoordIndex(Integer.parseInt(zValueSelector.getValue()));
 390                 validatePageComplete();
 391             }
 392         });
 393
 394         altElevationValueSelector = new DynamicComboFieldEditor("altElevation", "Alternative Elevation", parent);
 395         altElevationValueSelector.addComboListener(new SelectionListener() {
 396
 397             @Override
 398             public void widgetSelected(SelectionEvent e) {
 399                 widgetDefaultSelected(e);
 400             }
 401
 402             @Override
 403             public void widgetDefaultSelected(SelectionEvent e) {
 404                 model.setAltElevationIndex(Integer.parseInt(altElevationValueSelector.getValue()));
 405                 validatePageComplete();
 406             }
 407         });
 408
 409         supplyTempValueSelector = new DynamicComboFieldEditor("tempValue", "Supply Temperature value", parent);
 410         supplyTempValueSelector.addComboListener(new SelectionListener() {
 411
 412             @Override
 413             public void widgetSelected(SelectionEvent e) {
 414                 widgetDefaultSelected(e);
 415             }
 416
 417             @Override
 418             public void widgetDefaultSelected(SelectionEvent e) {
 419                 model.setSupplyTempIndex(Integer.parseInt(supplyTempValueSelector.getValue()));
 420                 validatePageComplete();
 421             }
 422         });
 423         returnTempValueSelector = new DynamicComboFieldEditor("returnTempValue", "Return Temperature value", parent);
 424         returnTempValueSelector.addComboListener(new SelectionListener() {
 425
 426             @Override
 427             public void widgetSelected(SelectionEvent e) {
 428                 widgetDefaultSelected(e);
 429             }
 430
 431             @Override
 432             public void widgetDefaultSelected(SelectionEvent e) {
 433                 model.setReturnTempIndex(Integer.parseInt(returnTempValueSelector.getValue()));
 434                 validatePageComplete();
 435             }
 436         });
 437         supplyPressureValueSelector = new DynamicComboFieldEditor("pressureValue", "Supply Pressure value", parent);
 438         supplyPressureValueSelector.addComboListener(new SelectionListener() {
 439
 440             @Override
 441             public void widgetSelected(SelectionEvent e) {
 442                 widgetDefaultSelected(e);
 443             }
 444
 445             @Override
 446             public void widgetDefaultSelected(SelectionEvent e) {
 447                 model.setSupplyPressureIndex(Integer.parseInt(supplyPressureValueSelector.getValue()));
 448                 validatePageComplete();
 449             }
 450         });
 451         returnPressureValueSelector = new DynamicComboFieldEditor("returnPressureValue", "Return Pressure value", parent);
 452         returnPressureValueSelector.addComboListener(new SelectionListener() {
 453
 454             @Override
 455             public void widgetSelected(SelectionEvent e) {
 456                 widgetDefaultSelected(e);
 457             }
 458
 459             @Override
 460             public void widgetDefaultSelected(SelectionEvent e) {
 461                 model.setReturnPressureIndex(Integer.parseInt(returnPressureValueSelector.getValue()));
 462                 validatePageComplete();
 463             }
 464         });
 465         dpSelector = new DynamicComboFieldEditor("dpValue", "Delta pressure ", parent);
 466         dpSelector.addComboListener(new SelectionListener() {
 467
 468             @Override
 469             public void widgetSelected(SelectionEvent e) {
 470                 widgetDefaultSelected(e);
 471             }
 472
 473             @Override
 474             public void widgetDefaultSelected(SelectionEvent e) {
 475                 model.setDeltaPressureIndex(Integer.parseInt(dpSelector.getValue()));
 476                 validatePageComplete();
 477             }
 478         });
 479         dtSelector = new DynamicComboFieldEditor("dtValue", "Delta temperature ", parent);
 480         dtSelector.addComboListener(new SelectionListener() {
 481
 482             @Override
 483             public void widgetSelected(SelectionEvent e) {
 484                 widgetDefaultSelected(e);
 485             }
 486
 487             @Override
 488             public void widgetDefaultSelected(SelectionEvent e) {
 489                 model.setDeltaTemperatureIndex(Integer.parseInt(dtSelector.getValue()));
 490                 validatePageComplete();
 491             }
 492         });
 493         heatPowerSelector = new DynamicComboFieldEditor("heatPowerValue", "Heat Power", parent);
 494         heatPowerSelector.addComboListener(new SelectionListener() {
 495
 496             @Override
 497             public void widgetSelected(SelectionEvent e) {
 498                 widgetDefaultSelected(e);
 499             }
 500
 501             @Override
 502             public void widgetDefaultSelected(SelectionEvent e) {
 503                 model.setHeatPowerIndex(Integer.parseInt(heatPowerSelector.getValue()));
 504                 validatePageComplete();
 505             }
 506         });
 507         peakPowerSelector = new DynamicComboFieldEditor("peakPowerValue", "Peak Power", parent);
 508         peakPowerSelector.addComboListener(new SelectionListener() {
 509
 510             @Override
 511             public void widgetSelected(SelectionEvent e) {
 512                 widgetDefaultSelected(e);
 513             }
 514
 515             @Override
 516             public void widgetDefaultSelected(SelectionEvent e) {
 517                 model.setPeakPowerIndex(Integer.parseInt(peakPowerSelector.getValue()));
 518                 validatePageComplete();
 519             }
 520         });
 521         nominalHeadMSelector = new DynamicComboFieldEditor("nominalHeadMValue", "nominalHeadM", parent);
 522         nominalHeadMSelector.addComboListener(new SelectionListener() {
 523
 524             @Override
 525             public void widgetSelected(SelectionEvent e) {
 526                 widgetDefaultSelected(e);
 527             }
 528
 529             @Override
 530             public void widgetDefaultSelected(SelectionEvent e) {
 531                 model.setNominalHeadMIndex(Integer.parseInt(nominalHeadMSelector.getValue()));
 532                 validatePageComplete();
 533             }
 534         });
 535         nominalHeadBSelector = new DynamicComboFieldEditor("nominalHeadBValue", "nominalHeadB", parent);
 536         nominalHeadBSelector.addComboListener(new SelectionListener() {
 537
 538             @Override
 539             public void widgetSelected(SelectionEvent e) {
 540                 widgetDefaultSelected(e);
 541             }
 542
 543             @Override
 544             public void widgetDefaultSelected(SelectionEvent e) {
 545                 model.setNominalHeadBIndex(Integer.parseInt(nominalHeadBSelector.getValue()));
 546                 validatePageComplete();
 547             }
 548         });
 549         nominalFlowSelector = new DynamicComboFieldEditor("nominalFlowValue", "nominalFlow", parent);
 550         nominalFlowSelector.addComboListener(new SelectionListener() {
 551
 552             @Override
 553             public void widgetSelected(SelectionEvent e) {
 554                 widgetDefaultSelected(e);
 555             }
 556
 557             @Override
 558             public void widgetDefaultSelected(SelectionEvent e) {
 559                 model.setNominalFlowIndex(Integer.parseInt(nominalFlowSelector.getValue()));
 560                 validatePageComplete();
 561             }
 562         });
 563
 564         maximumHeadMSelector = new DynamicComboFieldEditor("maximumHeadMValue", "maximumHeadM", parent);
 565         maximumHeadMSelector.addComboListener(new SelectionListener() {
 566
 567             @Override
 568             public void widgetSelected(SelectionEvent e) {
 569                 widgetDefaultSelected(e);
 570             }
 571
 572             @Override
 573             public void widgetDefaultSelected(SelectionEvent e) {
 574                 model.setMaximumHeadMIndex(Integer.parseInt(maximumHeadMSelector.getValue()));
 575                 validatePageComplete();
 576             }
 577         });
 578         heatLoadDsSelector = new DynamicComboFieldEditor("heatLoadDsValue", "heatLoadDs", parent);
 579         heatLoadDsSelector.addComboListener(new SelectionListener() {
 580
 581             @Override
 582             public void widgetSelected(SelectionEvent e) {
 583                 widgetDefaultSelected(e);
 584             }
 585
 586             @Override
 587             public void widgetDefaultSelected(SelectionEvent e) {
 588                 model.setHeatLoadDsIndex(Integer.parseInt(heatLoadDsSelector.getValue()));
 589                 validatePageComplete();
 590             }
 591         });
 592         massFlowSelector = new DynamicComboFieldEditor("massFlowValue", "massFlow", parent);
 593         massFlowSelector.addComboListener(new SelectionListener() {
 594
 595             @Override
 596             public void widgetSelected(SelectionEvent e) {
 597                 widgetDefaultSelected(e);
 598             }
 599
 600             @Override
 601             public void widgetDefaultSelected(SelectionEvent e) {
 602                 model.setMassFlowIndex(Integer.parseInt(massFlowSelector.getValue()));
 603                 validatePageComplete();
 604             }
 605         });
 606         volFlowSelector = new DynamicComboFieldEditor("volFlowValue", "volFlow", parent);
 607         volFlowSelector.addComboListener(new SelectionListener() {
 608
 609             @Override
 610             public void widgetSelected(SelectionEvent e) {
 611                 widgetDefaultSelected(e);
 612             }
 613
 614             @Override
 615             public void widgetDefaultSelected(SelectionEvent e) {
 616                 model.setVolFlowIndex(Integer.parseInt(volFlowSelector.getValue()));
 617                 validatePageComplete();
 618             }
 619         });
 620         velocitySelector = new DynamicComboFieldEditor("velocityValue", "velocity", parent);
 621         velocitySelector.addComboListener(new SelectionListener() {
 622
 623             @Override
 624             public void widgetSelected(SelectionEvent e) {
 625                 widgetDefaultSelected(e);
 626             }
 627
 628             @Override
 629             public void widgetDefaultSelected(SelectionEvent e) {
 630                 model.setVelocityIndex(Integer.parseInt(velocitySelector.getValue()));
 631                 validatePageComplete();
 632             }
 633         });
 634         flowAreaSelector = new DynamicComboFieldEditor("flowAreaValue", "flowArea", parent);
 635         flowAreaSelector.addComboListener(new SelectionListener() {
 636
 637             @Override
 638             public void widgetSelected(SelectionEvent e) {
 639                 widgetDefaultSelected(e);
 640             }
 641
 642             @Override
 643             public void widgetDefaultSelected(SelectionEvent e) {
 644                 model.setFlowAreaIndex(Integer.parseInt(flowAreaSelector.getValue()));
 645                 validatePageComplete();
 646             }
 647         });
 648         nominalPressureLossSelector = new DynamicComboFieldEditor("nominalPressureLossValue", "nominalPressureLoss", parent);
 649         nominalPressureLossSelector.addComboListener(new SelectionListener() {
 650
 651             @Override
 652             public void widgetSelected(SelectionEvent e) {
 653                 widgetDefaultSelected(e);
 654             }
 655
 656             @Override
 657             public void widgetDefaultSelected(SelectionEvent e) {
 658                 model.setNominalPressureLossIndex(Integer.parseInt(nominalPressureLossSelector.getValue()));
 659                 validatePageComplete();
 660             }
 661         });
 662         valvePositionSelector = new DynamicComboFieldEditor("valvePositionSelectorValue", "valvePositionSelector", parent);
 663         valvePositionSelector.addComboListener(new SelectionListener() {
 664
 665             @Override
 666             public void widgetSelected(SelectionEvent e) {
 667                 widgetDefaultSelected(e);
 668             }
 669
 670             @Override
 671             public void widgetDefaultSelected(SelectionEvent e) {
 672                 model.setValvePositionIndex(Integer.parseInt(valvePositionSelector.getValue()));
 673                 validatePageComplete();
 674             }
 675         });
 676         addressSelector = new DynamicComboFieldEditor("addressValue", "addressSelector", parent);
 677         addressSelector.addComboListener(new SelectionListener() {
 678
 679             @Override
 680             public void widgetSelected(SelectionEvent e) {
 681                 widgetDefaultSelected(e);
 682             }
 683
 684             @Override
 685             public void widgetDefaultSelected(SelectionEvent e) {
 686                 model.setAddressIndex(Integer.parseInt(addressSelector.getValue()));
 687                 validatePageComplete();
 688             }
 689         });
 690
 691
 692     }
 693
 694     private void createEdgeIndexMappingField(Group parent) {
 695
 696 //        Composite paddingComposite = new Composite(parent, SWT.NONE);
 697 //        GridLayoutFactory.fillDefaults().numColumns(2).applyTo(paddingComposite);
 698
 699         startXCoordSelector = new DynamicComboFieldEditor("startxCoord", "Start X Coordinate", parent);
 700         startXCoordSelector.addComboListener(new SelectionListener() {
 701
 702             @Override
 703             public void widgetSelected(SelectionEvent e) {
 704                 widgetDefaultSelected(e);
 705             }
 706
 707             @Override
 708             public void widgetDefaultSelected(SelectionEvent e) {
 709                 model.setStartXCoordIndex(Integer.parseInt(startXCoordSelector.getValue()));
 710                 validatePageComplete();
 711             }
 712         });
 713
 714         startYCoordSelector = new DynamicComboFieldEditor("startyCoord", "Start Y Coordinate", parent);
 715         startYCoordSelector.addComboListener(new SelectionListener() {
 716
 717             @Override
 718             public void widgetSelected(SelectionEvent e) {
 719                 widgetDefaultSelected(e);
 720             }
 721
 722             @Override
 723             public void widgetDefaultSelected(SelectionEvent e) {
 724                 model.setStartYCoordIndex(Integer.parseInt(startYCoordSelector.getValue()));
 725                 validatePageComplete();
 726             }
 727         });
 728         startZValueSelector = new DynamicComboFieldEditor("startzValue", "Start Z Value", parent);
 729         startZValueSelector.addComboListener(new SelectionListener() {
 730
 731             @Override
 732             public void widgetSelected(SelectionEvent e) {
 733                 widgetDefaultSelected(e);
 734             }
 735
 736             @Override
 737             public void widgetDefaultSelected(SelectionEvent e) {
 738                 model.setStartZCoordIndex(Integer.parseInt(startZValueSelector.getValue()));
 739                 validatePageComplete();
 740             }
 741         });
 742
 743         endXCoordSelector = new DynamicComboFieldEditor("endxCoord", "End X Coordinate", parent);
 744         endXCoordSelector.addComboListener(new SelectionListener() {
 745
 746             @Override
 747             public void widgetSelected(SelectionEvent e) {
 748                 widgetDefaultSelected(e);
 749             }
 750
 751             @Override
 752             public void widgetDefaultSelected(SelectionEvent e) {
 753                 model.setEndXCoordIndex(Integer.parseInt(endXCoordSelector.getValue()));
 754                 validatePageComplete();
 755             }
 756         });
 757
 758         endYCoordSelector = new DynamicComboFieldEditor("endyCoord", "End Y Coordinate", parent);
 759         endYCoordSelector.addComboListener(new SelectionListener() {
 760
 761             @Override
 762             public void widgetSelected(SelectionEvent e) {
 763                 widgetDefaultSelected(e);
 764             }
 765
 766             @Override
 767             public void widgetDefaultSelected(SelectionEvent e) {
 768                 model.setEndYCoordIndex(Integer.parseInt(endYCoordSelector.getValue()));
 769                 validatePageComplete();
 770             }
 771         });
 772         endZValueSelector = new DynamicComboFieldEditor("endzValue", "End Z Value", parent);
 773         endZValueSelector.addComboListener(new SelectionListener() {
 774
 775             @Override
 776             public void widgetSelected(SelectionEvent e) {
 777                 widgetDefaultSelected(e);
 778             }
 779
 780             @Override
 781             public void widgetDefaultSelected(SelectionEvent e) {
 782                 model.setEndZCoordIndex(Integer.parseInt(endZValueSelector.getValue()));
 783                 validatePageComplete();
 784             }
 785         });
 786         detailedGeometrySelector = new DynamicComboFieldEditor("detailedGeometryValue", "Geometry", parent);
 787         detailedGeometrySelector.addComboListener(new SelectionListener() {
 788
 789             @Override
 790             public void widgetSelected(SelectionEvent e) {
 791                 widgetDefaultSelected(e);
 792             }
 793
 794             @Override
 795             public void widgetDefaultSelected(SelectionEvent e) {
 796                 model.detailedGeometryIndex(Integer.parseInt(detailedGeometrySelector.getValue()));
 797                 validatePageComplete();
 798             }
 799         });
 800         diameterSelector = new DynamicComboFieldEditor("diameterValue", "Diameter value", parent);
 801         diameterSelector.addComboListener(new SelectionListener() {
 802
 803             @Override
 804             public void widgetSelected(SelectionEvent e) {
 805                 widgetDefaultSelected(e);
 806             }
 807
 808             @Override
 809             public void widgetDefaultSelected(SelectionEvent e) {
 810                 model.setDiameterIndex(Integer.parseInt(diameterSelector.getValue()));
 811                 validatePageComplete();
 812             }
 813         });
 814         outerDiameterSelector = new DynamicComboFieldEditor("outerDiameterValue", "Outer Diameter value", parent);
 815         outerDiameterSelector.addComboListener(new SelectionListener() {
 816
 817             @Override
 818             public void widgetSelected(SelectionEvent e) {
 819                 widgetDefaultSelected(e);
 820             }
 821
 822             @Override
 823             public void widgetDefaultSelected(SelectionEvent e) {
 824                 model.setOuterDiameterIndex(Integer.parseInt(outerDiameterSelector.getValue()));
 825                 validatePageComplete();
 826             }
 827         });
 828         nominalMassFlowSelector = new DynamicComboFieldEditor("nominalMassFlowValue", "Nominal Mass Flow", parent);
 829         nominalMassFlowSelector.addComboListener(new SelectionListener() {
 830
 831             @Override
 832             public void widgetSelected(SelectionEvent e) {
 833                 widgetDefaultSelected(e);
 834             }
 835
 836             @Override
 837             public void widgetDefaultSelected(SelectionEvent e) {
 838                 model.setNominalMassFlowIndex(Integer.parseInt(nominalMassFlowSelector.getValue()));
 839                 validatePageComplete();
 840             }
 841         });
 842         edgeFlowAreaSelector = new DynamicComboFieldEditor("edgeFlowAreaValue", "Flow Area", parent);
 843         edgeFlowAreaSelector.addComboListener(new SelectionListener() {
 844
 845             @Override
 846             public void widgetSelected(SelectionEvent e) {
 847                 widgetDefaultSelected(e);
 848             }
 849
 850             @Override
 851             public void widgetDefaultSelected(SelectionEvent e) {
 852                 model.setEdgeFlowAreaIndex(Integer.parseInt(edgeFlowAreaSelector.getValue()));
 853                 validatePageComplete();
 854             }
 855         });
 856         kReturnSelector = new DynamicComboFieldEditor("kReturnValue", "K Return", parent);
 857         kReturnSelector.addComboListener(new SelectionListener() {
 858
 859             @Override
 860             public void widgetSelected(SelectionEvent e) {
 861                 widgetDefaultSelected(e);
 862             }
 863
 864             @Override
 865             public void widgetDefaultSelected(SelectionEvent e) {
 866                 model.setKReturnIndex(Integer.parseInt(kReturnSelector.getValue()));
 867                 validatePageComplete();
 868             }
 869         });
 870         kSupplySelector = new DynamicComboFieldEditor("kSupplyValue", "K Supply", parent);
 871         kSupplySelector.addComboListener(new SelectionListener() {
 872
 873             @Override
 874             public void widgetSelected(SelectionEvent e) {
 875                 widgetDefaultSelected(e);
 876             }
 877
 878             @Override
 879             public void widgetDefaultSelected(SelectionEvent e) {
 880                 model.setKSupplyIndex(Integer.parseInt(kSupplySelector.getValue()));
 881                 validatePageComplete();
 882             }
 883         });
 884         tGroundSelector = new DynamicComboFieldEditor("tGroundValue", "Temperature Ground", parent);
 885         tGroundSelector.addComboListener(new SelectionListener() {
 886
 887             @Override
 888             public void widgetSelected(SelectionEvent e) {
 889                 widgetDefaultSelected(e);
 890             }
 891
 892             @Override
 893             public void widgetDefaultSelected(SelectionEvent e) {
 894                 model.setTGroundIndex(Integer.parseInt(tGroundSelector.getValue()));
 895                 validatePageComplete();
 896             }
 897         });
 898         lengthSelector = new DynamicComboFieldEditor("lengthValue", "lengthSelector", parent);
 899         lengthSelector.addComboListener(new SelectionListener() {
 900
 901             @Override
 902             public void widgetSelected(SelectionEvent e) {
 903                 widgetDefaultSelected(e);
 904             }
 905
 906             @Override
 907             public void widgetDefaultSelected(SelectionEvent e) {
 908                 model.setLengthIndex(Integer.parseInt(lengthSelector.getValue()));
 909                 validatePageComplete();
 910             }
 911         });
 912     }
 913
 914     private void updateCombos() {
 915         String[][] namesAndValues = new String[headerIndexAndValues.size() + 1][];
 916
 917         namesAndValues[0] = new String[] {"", "-1"};
 918         int i = 1;
 919         for (Entry<Integer, String> entry : headerIndexAndValues.entrySet()) {
 920             int key = entry.getKey();
 921             String value = entry.getValue();
 922
 923             String[] nameAndValue = new String[2];
 924             nameAndValue[0] = value;
 925             nameAndValue[1] = Integer.toString(key);
 926             namesAndValues[i++] = nameAndValue;
 927         }
 928
 929         if (model.isVertexImport())
 930             updateVertexCombos(namesAndValues);
 931         else
 932             updateEdgeCombos(namesAndValues);
 933
 934         componentMappingSelector.updateCombo(namesAndValues);
 935         idSelector.updateCombo(namesAndValues);
 936     }
 937
 938     private void updateEdgeCombos(String[][] namesAndValues) {
 939         startXCoordSelector.updateCombo(namesAndValues);
 940         endXCoordSelector.updateCombo(namesAndValues);
 941         startYCoordSelector.updateCombo(namesAndValues);
 942         endYCoordSelector.updateCombo(namesAndValues);
 943         startZValueSelector.updateCombo(namesAndValues);
 944         endZValueSelector.updateCombo(namesAndValues);
 945         detailedGeometrySelector.updateCombo(namesAndValues);
 946         diameterSelector.updateCombo(namesAndValues);
 947         outerDiameterSelector.updateCombo(namesAndValues);
 948         nominalMassFlowSelector.updateCombo(namesAndValues);
 949         edgeFlowAreaSelector.updateCombo(namesAndValues);
 950         kReturnSelector.updateCombo(namesAndValues);
 951         kSupplySelector.updateCombo(namesAndValues);
 952         tGroundSelector.updateCombo(namesAndValues);
 953         lengthSelector.updateCombo(namesAndValues);
 954     }
 955
 956     private void updateVertexCombos(String[][] namesAndValues) {
 957         xCoordSelector.updateCombo(namesAndValues);
 958         yCoordSelector.updateCombo(namesAndValues);
 959         zValueSelector.updateCombo(namesAndValues);
 960         altElevationValueSelector.updateCombo(namesAndValues);
 961         supplyTempValueSelector.updateCombo(namesAndValues);
 962         returnTempValueSelector.updateCombo(namesAndValues);
 963         supplyPressureValueSelector.updateCombo(namesAndValues);
 964         returnPressureValueSelector.updateCombo(namesAndValues);
 965         dpSelector.updateCombo(namesAndValues);
 966         dtSelector.updateCombo(namesAndValues);
 967         heatPowerSelector.updateCombo(namesAndValues);
 968         valvePositionSelector.updateCombo(namesAndValues);
 969         nominalHeadMSelector.updateCombo(namesAndValues);
 970         nominalHeadBSelector.updateCombo(namesAndValues);
 971         nominalFlowSelector.updateCombo(namesAndValues);
 972         maximumHeadMSelector.updateCombo(namesAndValues);
 973         heatLoadDsSelector.updateCombo(namesAndValues);
 974         massFlowSelector.updateCombo(namesAndValues);
 975         volFlowSelector.updateCombo(namesAndValues);
 976         velocitySelector.updateCombo(namesAndValues);
 977         flowAreaSelector.updateCombo(namesAndValues);
 978         nominalPressureLossSelector.updateCombo(namesAndValues);
 979         addressSelector.updateCombo(namesAndValues);
 980     }
 981
 982
 983
 984     private void updateHeaders() {
 985         if (headerTable != null)
 986             headerTable.dispose();
 987         headerTable = new Table(tableComposite, SWT.NONE);
 988         headerTable.setHeaderVisible(true);
 989         headerTable.setLinesVisible(true);
 990         GridDataFactory.fillDefaults().grab(true, true).align(SWT.FILL, SWT.FILL).applyTo(tableComposite);
 991         for (int i = 0; i < headerTable.getColumns().length; i++) {
 992             TableColumn column = headerTable.getColumns()[i];
 993             column.dispose();
 994         }
 995         for (int i = 0; i < headerTable.getItemCount(); i++) {
 996             TableItem item = headerTable.getItem(i);
 997             item.dispose();
 998         }
 999
1000         headerIndexAndValues.clear();
1001
1002         try {
1003             List<CSVRecord> rows = model.getRows(5, false);
1004
1005             for (int k = 0; k < rows.size(); k++) {
1006                 CSVRecord row = rows.get(k);
1007
1008                 int columnCount = row.size();
1009                 for (int i = 0; i < columnCount; i++) {
1010                     String value = row.get(i);
1011                     if (k == 0) {
1012                         TableColumn headerCol = new TableColumn(headerTable, SWT.NONE);
1013                         headerCol.setText(value);
1014
1015                         tableColumnLayout.setColumnData(headerCol, new ColumnWeightData(10));
1016                         headerCol.pack();
1017
1018                         headerIndexAndValues.put(i, value);
1019                     } else {
1020                         int actualK = k - 1;
1021                         TableItem item;
1022                         int itemCount = headerTable.getItemCount();
1023                         if (actualK >= itemCount) {
1024                             item = new TableItem(headerTable, SWT.NONE);
1025                         } else {
1026                             item = headerTable.getItem(actualK);
1027                         }
1028                         item.setText(i, value);
1029                     }
1030                 }
1031             }
1032
1033         } catch (IOException e) {
1034             setErrorMessage(e.getMessage());
1035         }
1036     }
1037
1038     protected void validatePageComplete() {
1039         if (model.isVertexImport())
1040             setPageComplete(model.getXCoordIndex() != -1 && model.getYCoordIndex() != -1 && model.getComponentMappingIndex() != -1);
1041         else
1042             setPageComplete(model.getStartXCoordIndex() != -1 && model.getStartYCoordIndex() != -1 && model.getEndXCoordIndex() != -1 && model.getEndYCoordIndex() != -1 && model.getComponentMappingIndex() != -1);
1043     }
1044
1045 }