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