X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=org.simantics.district.imports.ui%2Fsrc%2Forg%2Fsimantics%2Fdistrict%2Fimports%2Fui%2FCSVImportWizardPage.java;h=5db4581584e6110147a87173b0fa3bb0e6aca5bf;hb=refs%2Fchanges%2F72%2F4472%2F1;hp=71017b321b90d9486974021f75d01ca4a764b517;hpb=8034693a5c86d690649a70a62709d29c3fa197aa;p=simantics%2Fdistrict.git diff --git a/org.simantics.district.imports.ui/src/org/simantics/district/imports/ui/CSVImportWizardPage.java b/org.simantics.district.imports.ui/src/org/simantics/district/imports/ui/CSVImportWizardPage.java index 71017b32..5db45815 100644 --- a/org.simantics.district.imports.ui/src/org/simantics/district/imports/ui/CSVImportWizardPage.java +++ b/org.simantics.district.imports.ui/src/org/simantics/district/imports/ui/CSVImportWizardPage.java @@ -1,168 +1,558 @@ -package org.simantics.district.imports.ui; - -import java.io.IOException; -import java.nio.file.Files; -import java.nio.file.Path; -import java.nio.file.Paths; -import java.util.Collections; -import java.util.List; -import java.util.Map; - -import org.eclipse.jface.layout.GridDataFactory; -import org.eclipse.jface.layout.TableColumnLayout; -import org.eclipse.jface.layout.TreeColumnLayout; -import org.eclipse.jface.viewers.ColumnViewerToolTipSupport; -import org.eclipse.jface.viewers.ColumnWeightData; -import org.eclipse.jface.viewers.IContentProvider; -import org.eclipse.jface.viewers.TableViewer; -import org.eclipse.jface.viewers.TreeViewer; -import org.eclipse.jface.viewers.Viewer; -import org.eclipse.jface.wizard.WizardPage; -import org.eclipse.swt.SWT; -import org.eclipse.swt.events.SelectionEvent; -import org.eclipse.swt.events.SelectionListener; -import org.eclipse.swt.layout.GridData; -import org.eclipse.swt.layout.GridLayout; -import org.eclipse.swt.widgets.Button; -import org.eclipse.swt.widgets.Combo; -import org.eclipse.swt.widgets.Composite; -import org.eclipse.swt.widgets.Layout; -import org.eclipse.swt.widgets.Table; -import org.eclipse.swt.widgets.TableColumn; -import org.eclipse.swt.widgets.TableItem; -import org.simantics.district.imports.DistrictImportUtils.CSVHeader; -import org.simantics.utils.ui.widgets.FileOrDirectorySelectionWidget; -import org.simantics.utils.ui.widgets.FileSelectionListener; -import org.simantics.utils.ui.widgets.FileSelectionWidget; - -public class CSVImportWizardPage extends WizardPage implements FileSelectionListener { - - private CSVImportModel model; - private FileSelectionWidget csvSelection; - private Table headerTable; - private Button firstAsHeader; - private Combo delimiterCombo; - private TableColumnLayout tableColumnLayout; - private TableViewer tableViewer; - private Composite tableComposite; - - protected CSVImportWizardPage(CSVImportModel model) { - super("Import CSV Data"); - this.model = model; - setMessage("Select CSV file to import"); - } - - @Override - public void createControl(Composite parent) { - Composite composite = new Composite(parent, SWT.NONE); - composite.setLayout(new GridLayout(1,false)); - GridDataFactory.fillDefaults().grab(true, true).align(SWT.FILL, SWT.FILL).applyTo(composite); - - csvSelection = new FileSelectionWidget(composite, "CSV file", SWT.OPEN); - csvSelection.addListener(this); - - delimiterCombo = new Combo(composite, SWT.DROP_DOWN | SWT.READ_ONLY); - delimiterCombo.setItems(model.getDelimiterFormats()); - delimiterCombo.addSelectionListener(new SelectionListener() { - - @Override - public void widgetSelected(SelectionEvent e) { - model.setDelimiterByLabel(delimiterCombo.getItem(delimiterCombo.getSelectionIndex())); - updateHeaders(); - } - - @Override - public void widgetDefaultSelected(SelectionEvent e) { - - } - }); - - firstAsHeader = new Button(composite, SWT.CHECK); - firstAsHeader.setText("Read first row as header"); - firstAsHeader.setSelection(model.getReadFirstAsHeader()); - firstAsHeader.addSelectionListener(new SelectionListener() { - - @Override - public void widgetSelected(SelectionEvent e) { - model.setReadFirstAsHeader(firstAsHeader.getSelection()); - updateHeaders(); - } - - @Override - public void widgetDefaultSelected(SelectionEvent e) { - - } - }); - - - tableComposite = new Composite(composite, SWT.BORDER); - tableColumnLayout = new TableColumnLayout(); - tableComposite.setLayout(tableColumnLayout); - - updateHeaders(); - - setControl(composite); - - - - setPageComplete(false); - } - - @Override - public void fileSelected(FileOrDirectorySelectionWidget source, String[] filename) { - String[] selection = csvSelection.getFilename(); - if (selection != null && selection.length > 0) { - Path csvFile = Paths.get(selection[0]); - if (!Files.exists(csvFile)) { - setErrorMessage("File " + csvFile.toAbsolutePath() + " does not exist"); - } else { - model.setSource(csvFile); - updateHeaders(); - setPageComplete(true); - } - } else { - setPageComplete(false); - } - } - - private void updateHeaders() { - if (headerTable != null) - headerTable.dispose(); - headerTable = new Table(tableComposite, SWT.NONE); - headerTable.setHeaderVisible(true); - headerTable.setLinesVisible(true); - GridDataFactory.fillDefaults().grab(true, true).align(SWT.FILL, SWT.FILL).applyTo(tableComposite); - for (int i = 0; i < headerTable.getColumns().length; i++) { - TableColumn column = headerTable.getColumns()[i]; - column.dispose(); - } - for (int i = 0; i < headerTable.getItemCount(); i++) { - TableItem item = headerTable.getItem(i); - item.dispose(); - } - try { - Map> headerAndValues = model.getHeaderAndRows(5); - - int coo = headerTable.getColumns().length; - int count = headerTable.getColumnCount(); - - for (Map.Entry> entr : headerAndValues.entrySet()) { - CSVHeader he = entr.getKey(); - int index = he.getIndex(); - TableColumn headerCol = new TableColumn(headerTable, SWT.NONE); - headerCol.setText(he.getHeader()); - - tableColumnLayout.setColumnData(headerCol, new ColumnWeightData(10)); - headerCol.pack(); - - for (String val : entr.getValue()) { - TableItem item = new TableItem(headerTable, SWT.NONE); - item.setText(val); - } - } - } catch (IOException e) { - setErrorMessage(e.getMessage()); - } - } - -} +package org.simantics.district.imports.ui; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; +import java.util.function.Consumer; + +import org.apache.commons.csv.CSVRecord; +import org.eclipse.jface.dialogs.IPageChangeProvider; +import org.eclipse.jface.dialogs.IPageChangedListener; +import org.eclipse.jface.dialogs.PageChangedEvent; +import org.eclipse.jface.layout.GridDataFactory; +import org.eclipse.jface.layout.TableColumnLayout; +import org.eclipse.jface.viewers.ColumnWeightData; +import org.eclipse.jface.wizard.IWizardContainer; +import org.eclipse.jface.wizard.WizardPage; +import org.eclipse.swt.SWT; +import org.eclipse.swt.events.ModifyEvent; +import org.eclipse.swt.events.ModifyListener; +import org.eclipse.swt.events.SelectionAdapter; +import org.eclipse.swt.events.SelectionEvent; +import org.eclipse.swt.events.SelectionListener; +import org.eclipse.swt.layout.GridLayout; +import org.eclipse.swt.widgets.Button; +import org.eclipse.swt.widgets.Combo; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Group; +import org.eclipse.swt.widgets.Label; +import org.eclipse.swt.widgets.Table; +import org.eclipse.swt.widgets.TableColumn; +import org.eclipse.swt.widgets.TableItem; +import org.eclipse.swt.widgets.Text; +import org.geotools.referencing.CRS; +import org.simantics.district.imports.CSVImportModel; +import org.simantics.district.network.ui.DynamicComboFieldEditor; + +public class CSVImportWizardPage extends WizardPage { + + private CSVImportModel model; + + private Map headerIndexAndValues = new HashMap<>(); + + private Table headerTable; +// private Button firstAsHeader; + + private Combo delimiterCombo; + private TableColumnLayout tableColumnLayout; + private Composite tableComposite; +// private FileSelectionWidget wktFileSelection; + + // Common for vertex and edge + private DynamicComboFieldEditor componentMappingSelector; + private DynamicComboFieldEditor idSelector; + + // For vertex import + private DynamicComboFieldEditor xCoordSelector; + private DynamicComboFieldEditor yCoordSelector; + private DynamicComboFieldEditor zValueSelector; + private DynamicComboFieldEditor altElevationValueSelector; + + private DynamicComboFieldEditor supplyTempValueSelector; + private DynamicComboFieldEditor returnTempValueSelector; + private DynamicComboFieldEditor supplyPressureValueSelector; + private DynamicComboFieldEditor returnPressureValueSelector; + private DynamicComboFieldEditor dpSelector; + private DynamicComboFieldEditor dtSelector; + private DynamicComboFieldEditor heatPowerSelector; + private DynamicComboFieldEditor peakPowerSelector; + private DynamicComboFieldEditor regionSelector; + private DynamicComboFieldEditor nominalHeadMSelector; + private DynamicComboFieldEditor nominalHeadBSelector; + private DynamicComboFieldEditor nominalFlowSelector; + private DynamicComboFieldEditor maximumHeadMSelector; + private DynamicComboFieldEditor heatLoadDsSelector; + private DynamicComboFieldEditor massFlowSelector; + private DynamicComboFieldEditor volFlowSelector; + private DynamicComboFieldEditor velocitySelector; + private DynamicComboFieldEditor flowAreaSelector; + private DynamicComboFieldEditor nominalPressureLossSelector; + private DynamicComboFieldEditor valvePositionSelector; + private DynamicComboFieldEditor addressSelector; + private DynamicComboFieldEditor lengthSelector; + + // For edge import + private DynamicComboFieldEditor startXCoordSelector; + private DynamicComboFieldEditor startYCoordSelector; + private DynamicComboFieldEditor startZValueSelector; + private DynamicComboFieldEditor endXCoordSelector; + private DynamicComboFieldEditor endYCoordSelector; + private DynamicComboFieldEditor endZValueSelector; + private DynamicComboFieldEditor detailedGeometrySelector; + private DynamicComboFieldEditor pipeCodeSelector; + private DynamicComboFieldEditor installationYearSelector; + private DynamicComboFieldEditor wallThicknessSelector; + private DynamicComboFieldEditor insulationConductivitySelector; + private DynamicComboFieldEditor pipeSizeDNSelector; + private DynamicComboFieldEditor roughnessSelector; + private DynamicComboFieldEditor structureSelector; + + private Text edgeConnectionPadding; + + private DynamicComboFieldEditor outerDiameterSelector; + private DynamicComboFieldEditor diameterSelector; + private DynamicComboFieldEditor nominalMassFlowSelector; + + private Group indexMappingGroup; + + private Composite composite; + + private Button isVertexImport; + + private Combo sourceCRSCombo; + + private DynamicComboFieldEditor edgeFlowAreaSelector; + + private DynamicComboFieldEditor kReturnSelector; + + private DynamicComboFieldEditor kSupplySelector; + + private DynamicComboFieldEditor tGroundSelector; + + protected CSVImportWizardPage(CSVImportModel model) { + super("Import CSV Data"); + this.model = model; + setMessage("Select column index mappings"); + } + + @Override + public void createControl(Composite parent) { + composite = new Composite(parent, SWT.NONE); + composite.setLayout(new GridLayout(1, false)); + GridDataFactory.fillDefaults().grab(true, true).align(SWT.FILL, SWT.FILL).applyTo(composite); + + Label label = new Label(composite, SWT.NONE); + label.setText("Select delimiter"); + + delimiterCombo = new Combo(composite, SWT.DROP_DOWN | SWT.READ_ONLY); + delimiterCombo.setToolTipText("Select the delimiter that is used to separate elements in the CSV file"); + String[] formats = model.getDelimiterFormats(); + delimiterCombo.setItems(formats); + if (formats.length > 0) + delimiterCombo.select(0); + delimiterCombo.addSelectionListener(new SelectionListener() { + + @Override + public void widgetSelected(SelectionEvent e) { + model.setDelimiterByLabel(delimiterCombo.getItem(delimiterCombo.getSelectionIndex())); + updateHeaders(); + updateCombos(); + } + + @Override + public void widgetDefaultSelected(SelectionEvent e) { + widgetSelected(e); + } + }); + +// firstAsHeader = new Button(composite, SWT.CHECK); +// firstAsHeader.setText("Read first row as header"); +// firstAsHeader.setSelection(model.getReadFirstAsHeader()); +// firstAsHeader.addSelectionListener(new SelectionListener() { +// +// @Override +// public void widgetSelected(SelectionEvent e) { +// model.setReadFirstAsHeader(firstAsHeader.getSelection()); +// updateHeaders(); +// updateCombos(); +// } +// +// @Override +// public void widgetDefaultSelected(SelectionEvent e) { +// widgetSelected(e); +// } +// }); + + tableComposite = new Composite(composite, SWT.BORDER); + tableColumnLayout = new TableColumnLayout(); + tableComposite.setLayout(tableColumnLayout); + + label = new Label(composite, SWT.NONE); + label.setText("Select source Coordinate Reference System"); + + sourceCRSCombo = new Combo(composite, SWT.NONE); + sourceCRSCombo.setToolTipText("Select the coordinate reference system that is used in the source material for possible transformation to target coordinate reference system (EPSG:4326)"); + Set codes = CRS.getSupportedCodes("EPSG"); + sourceCRSCombo.setItems(codes.toArray(new String[codes.size()])); + sourceCRSCombo.addSelectionListener(new SelectionAdapter() { + + @Override + public void widgetSelected(SelectionEvent e) { + String current = sourceCRSCombo.getItem(sourceCRSCombo.getSelectionIndex()); + model.setSourceCRS("EPSG:" + current); + } + }); + + sourceCRSCombo.addModifyListener(new ModifyListener() { + + @Override + public void modifyText(ModifyEvent e) { + String currentText = sourceCRSCombo.getText(); + if (codes.contains(currentText)) { + // Select this + String[] items = sourceCRSCombo.getItems(); + int i; + for (i = 0; i < items.length; i++) { + String item = items[i]; + if (currentText.equals(item)) { + break; + } + } + if (i != 0) { + sourceCRSCombo.select(i); + model.setSourceCRS("EPSG:" + currentText); + } else { + System.err.println("this should not happen"); + } + } + } + }); + +// wktFileSelection = new FileSelectionWidget(composite, "WKT file", SWT.OPEN); +// wktFileSelection.addListener(new FileSelectionListener() { +// +// @Override +// public void fileSelected(FileOrDirectorySelectionWidget source, String[] filename) { +// String[] selection = wktFileSelection.getFilename(); +// if (selection != null && selection.length > 0) { +// Path wktFile = Paths.get(selection[0]); +// if (!Files.exists(wktFile)) { +// setErrorMessage("File " + wktFile.toAbsolutePath() + " does not exist"); +// } else { +// model.setWKTFile(wktFile); +// validatePageComplete(); +// } +// } +// } +// }); + + isVertexImport = new Button(composite, SWT.CHECK); + isVertexImport.setText("File contains vertices"); + isVertexImport.setToolTipText("Enable this if the file contains vertices, i.e. points"); + isVertexImport.setSelection(model.isVertexImport()); + isVertexImport.addSelectionListener(new SelectionListener() { + + @Override + public void widgetSelected(SelectionEvent e) { + model.setVertexImport(isVertexImport.getSelection()); + updateControls(false); + } + + @Override + public void widgetDefaultSelected(SelectionEvent e) { + widgetSelected(e); + } + }); + + updateControls(true); + updateHeaders(); + setControl(composite); + + final IWizardContainer container = getContainer(); + + if (container instanceof IPageChangeProvider) { + ((IPageChangeProvider) container).addPageChangedListener(new IPageChangedListener() { + + @Override + public void pageChanged(PageChangedEvent event) { + if (isCurrentPage()) + CSVImportWizardPage.this.updateControls(false); + } + }); + } + + validatePageComplete(); + } + + private void updateControls(boolean initial) { + createIndexMappingGroup(); + updateCombos(); + if (!initial) + composite.layout(true, true); + } + + private void createIndexMappingGroup() { + if (indexMappingGroup != null) + indexMappingGroup.dispose(); + + indexMappingGroup = new Group(composite, SWT.NONE); + indexMappingGroup.setText("Column index mapping"); + GridDataFactory.fillDefaults().grab(true, false).span(2, 1).applyTo(indexMappingGroup); + + if (model.isVertexImport()) + createVertexIndexMappingField(indexMappingGroup); + else + createEdgeIndexMappingField(indexMappingGroup); + + createCommonIndexMappingField(indexMappingGroup); + + if (!model.isVertexImport()) { + Label label = new Label(indexMappingGroup, SWT.NONE); + label.setText("Connection point padding"); + GridDataFactory.fillDefaults().applyTo(label); + edgeConnectionPadding = new Text(indexMappingGroup, SWT.BORDER); + GridDataFactory.fillDefaults().applyTo(edgeConnectionPadding); + edgeConnectionPadding.setText("0.0001"); // default + edgeConnectionPadding.addModifyListener(new ModifyListener() { + + @Override + public void modifyText(ModifyEvent e) { + try { + double padding = Double.parseDouble(edgeConnectionPadding.getText()); + model.setEdgePadding(padding); + } catch (NumberFormatException ee) { + // ignore + } + } + }); + } + } + + private void createCommonIndexMappingField(Group parent) { + + componentMappingSelector = createComboField("componentMapping", "Apros component mapping", model::setComponentMappingIndex, parent); + + idSelector = createComboField("id", "ID", model::setIdIndex, parent); + regionSelector = createComboField("regionValue", "Region", model::setRegionIndex, parent); + } + + private DynamicComboFieldEditor createComboField(String name, String label, Consumer setter, Group parent) { + DynamicComboFieldEditor selector = new DynamicComboFieldEditor(name, label, parent); + createSelectionListener(selector, setter); + return selector; + } + + private void createSelectionListener(DynamicComboFieldEditor editor, Consumer setter) { + editor.addComboListener(new SelectionListener() { + + @Override + public void widgetSelected(SelectionEvent e) { + widgetDefaultSelected(e); + } + + @Override + public void widgetDefaultSelected(SelectionEvent e) { + setter.accept(Integer.parseInt(editor.getValue())); + validatePageComplete(); + } + }); + } + + private void createVertexIndexMappingField(Group parent) { + xCoordSelector = createComboField("xCoord", "X Coordinate", model::setXCoordIndex, parent); + + yCoordSelector = createComboField("yCoord", "Y Coordinate", model::setYCoordIndex, parent); + zValueSelector = createComboField("zValue", "Z Value", model::setZCoordIndex, parent); + + altElevationValueSelector = createComboField("altElevation", "Alternative Elevation", model::setAltElevationIndex, parent); + + supplyTempValueSelector = createComboField("tempValue", "Supply Temperature value", model::setSupplyTempIndex, parent); + returnTempValueSelector = createComboField("returnTempValue", "Return Temperature value", model::setReturnTempIndex, parent); + supplyPressureValueSelector = createComboField("pressureValue", "Supply Pressure value", model::setSupplyPressureIndex, parent); + returnPressureValueSelector = createComboField("returnPressureValue", "Return Pressure value", model::setReturnPressureIndex, parent); + dpSelector = createComboField("dpValue", "Delta pressure ", model::setDeltaPressureIndex, parent); + dtSelector = createComboField("dtValue", "Delta temperature ", model::setDeltaTemperatureIndex, parent); + heatPowerSelector = createComboField("heatPowerValue", "Heat Power", model::setHeatPowerIndex, parent); + peakPowerSelector = createComboField("peakPowerValue", "Peak Power", model::setPeakPowerIndex, parent); + + nominalHeadMSelector = createComboField("nominalHeadMValue", "nominalHeadM", model::setNominalHeadMIndex, parent); + nominalHeadBSelector = createComboField("nominalHeadBValue", "nominalHeadB", model::setNominalHeadBIndex, parent); + nominalFlowSelector = createComboField("nominalFlowValue", "nominalFlow", model::setNominalFlowIndex, parent); + + maximumHeadMSelector = createComboField("maximumHeadMValue", "maximumHeadM", model::setMaximumHeadMIndex, parent); + heatLoadDsSelector = createComboField("heatLoadDsValue", "heatLoadDs", model::setHeatLoadDsIndex, parent); + massFlowSelector = createComboField("massFlowValue", "massFlow", model::setMassFlowIndex, parent); + volFlowSelector = createComboField("volFlowValue", "volFlow", model::setVolFlowIndex, parent); + velocitySelector = createComboField("velocityValue", "velocity", model::setVelocityIndex, parent); + flowAreaSelector = createComboField("flowAreaValue", "flowArea", model::setFlowAreaIndex, parent); + nominalPressureLossSelector = createComboField("nominalPressureLossValue", "nominalPressureLoss", model::setNominalPressureLossIndex, parent); + valvePositionSelector = createComboField("valvePositionSelectorValue", "valvePositionSelector", model::setValvePositionIndex, parent); + addressSelector = createComboField("addressValue", "addressSelector", model::setAddressIndex, parent); + + + } + + private void createEdgeIndexMappingField(Group parent) { + +// Composite paddingComposite = new Composite(parent, SWT.NONE); +// GridLayoutFactory.fillDefaults().numColumns(2).applyTo(paddingComposite); + startXCoordSelector = createComboField("startxCoord", "Start X Coordinate", model::setStartXCoordIndex, parent); + startYCoordSelector = createComboField("startyCoord", "Start Y Coordinate", model::setStartYCoordIndex, parent); + startZValueSelector = createComboField("startzValue", "Start Z Value", model::setStartZCoordIndex, parent); + + endXCoordSelector = createComboField("endxCoord", "End X Coordinate", model::setEndXCoordIndex, parent); + endYCoordSelector = createComboField("endyCoord", "End Y Coordinate", model::setEndYCoordIndex, parent); + endZValueSelector = createComboField("endzValue", "End Z Value", model::setEndZCoordIndex, parent); + + pipeCodeSelector = createComboField("pipeCodeValue", "Pipe Code", model::setPipeCodeIndex, parent); + + detailedGeometrySelector = createComboField("detailedGeometryValue", "Geometry", model::detailedGeometryIndex, parent); + diameterSelector = createComboField("diameterValue", "Diameter value", model::setDiameterIndex, parent); + outerDiameterSelector = createComboField("outerDiameterValue", "Outer Diameter value", model::setOuterDiameterIndex, parent); + nominalMassFlowSelector = createComboField("nominalMassFlowValue", "Nominal Mass Flow", model::setNominalMassFlowIndex, parent); + edgeFlowAreaSelector = createComboField("edgeFlowAreaValue", "Flow Area", model::setEdgeFlowAreaIndex, parent); + kReturnSelector = createComboField("kReturnValue", "K Return", model::setKReturnIndex, parent); + kSupplySelector = createComboField("kSupplyValue", "K Supply", model::setKSupplyIndex, parent); + tGroundSelector = createComboField("tGroundValue", "Temperature Ground", model::setTGroundIndex, parent); + lengthSelector = createComboField("lengthValue", "lengthSelector", model::setLengthIndex, parent); + + pipeSizeDNSelector = createComboField("pipeSizeDNValue", "Pipe Size DN", model::setPipeSizeDNIndex, parent); + structureSelector = createComboField("structureValue", "Structure", model::setStructureIndex, parent); + installationYearSelector = createComboField("installationYearValue", "Installation Year", model::setInstallationYearIndex, parent); + wallThicknessSelector = createComboField("wallThicknessValue", "Wall Thickness", model::setWallThicknessIndex, parent); + insulationConductivitySelector = createComboField("insulationConductivityValue", "Insulation Conductivity", model::setInsulationConductivityIndex, parent); + roughnessSelector = createComboField("roughnessValue", "Roughness", model::setRoughnessIndex, parent); + } + + private void updateCombos() { + String[][] namesAndValues = new String[headerIndexAndValues.size() + 1][]; + + namesAndValues[0] = new String[] {"", "-1"}; + int i = 1; + for (Entry entry : headerIndexAndValues.entrySet()) { + int key = entry.getKey(); + String value = entry.getValue(); + + String[] nameAndValue = new String[2]; + nameAndValue[0] = value; + nameAndValue[1] = Integer.toString(key); + namesAndValues[i++] = nameAndValue; + } + + if (model.isVertexImport()) + updateVertexCombos(namesAndValues); + else + updateEdgeCombos(namesAndValues); + + componentMappingSelector.updateCombo(namesAndValues); + idSelector.updateCombo(namesAndValues); + } + + private void updateEdgeCombos(String[][] namesAndValues) { + startXCoordSelector.updateCombo(namesAndValues); + endXCoordSelector.updateCombo(namesAndValues); + startYCoordSelector.updateCombo(namesAndValues); + endYCoordSelector.updateCombo(namesAndValues); + startZValueSelector.updateCombo(namesAndValues); + endZValueSelector.updateCombo(namesAndValues); + pipeCodeSelector.updateCombo(namesAndValues); + detailedGeometrySelector.updateCombo(namesAndValues); + diameterSelector.updateCombo(namesAndValues); + outerDiameterSelector.updateCombo(namesAndValues); + nominalMassFlowSelector.updateCombo(namesAndValues); + edgeFlowAreaSelector.updateCombo(namesAndValues); + kReturnSelector.updateCombo(namesAndValues); + kSupplySelector.updateCombo(namesAndValues); + tGroundSelector.updateCombo(namesAndValues); + lengthSelector.updateCombo(namesAndValues); + pipeSizeDNSelector.updateCombo(namesAndValues); + structureSelector.updateCombo(namesAndValues); + installationYearSelector.updateCombo(namesAndValues); + wallThicknessSelector.updateCombo(namesAndValues); + insulationConductivitySelector.updateCombo(namesAndValues); + roughnessSelector.updateCombo(namesAndValues); + } + + private void updateVertexCombos(String[][] namesAndValues) { + xCoordSelector.updateCombo(namesAndValues); + yCoordSelector.updateCombo(namesAndValues); + zValueSelector.updateCombo(namesAndValues); + altElevationValueSelector.updateCombo(namesAndValues); + supplyTempValueSelector.updateCombo(namesAndValues); + returnTempValueSelector.updateCombo(namesAndValues); + supplyPressureValueSelector.updateCombo(namesAndValues); + returnPressureValueSelector.updateCombo(namesAndValues); + dpSelector.updateCombo(namesAndValues); + dtSelector.updateCombo(namesAndValues); + heatPowerSelector.updateCombo(namesAndValues); + valvePositionSelector.updateCombo(namesAndValues); + nominalHeadMSelector.updateCombo(namesAndValues); + nominalHeadBSelector.updateCombo(namesAndValues); + nominalFlowSelector.updateCombo(namesAndValues); + maximumHeadMSelector.updateCombo(namesAndValues); + heatLoadDsSelector.updateCombo(namesAndValues); + massFlowSelector.updateCombo(namesAndValues); + volFlowSelector.updateCombo(namesAndValues); + velocitySelector.updateCombo(namesAndValues); + flowAreaSelector.updateCombo(namesAndValues); + nominalPressureLossSelector.updateCombo(namesAndValues); + addressSelector.updateCombo(namesAndValues); + } + + + + private void updateHeaders() { + if (headerTable != null) + headerTable.dispose(); + headerTable = new Table(tableComposite, SWT.NONE); + headerTable.setHeaderVisible(true); + headerTable.setLinesVisible(true); + GridDataFactory.fillDefaults().grab(true, true).align(SWT.FILL, SWT.FILL).applyTo(tableComposite); + for (int i = 0; i < headerTable.getColumns().length; i++) { + TableColumn column = headerTable.getColumns()[i]; + column.dispose(); + } + for (int i = 0; i < headerTable.getItemCount(); i++) { + TableItem item = headerTable.getItem(i); + item.dispose(); + } + + headerIndexAndValues.clear(); + + try { + List rows = model.getRows(5, false); + + for (int k = 0; k < rows.size(); k++) { + CSVRecord row = rows.get(k); + + int columnCount = row.size(); + for (int i = 0; i < columnCount; i++) { + String value = row.get(i); + if (k == 0) { + TableColumn headerCol = new TableColumn(headerTable, SWT.NONE); + headerCol.setText(value); + + tableColumnLayout.setColumnData(headerCol, new ColumnWeightData(10)); + headerCol.pack(); + + headerIndexAndValues.put(i, value); + } else { + int actualK = k - 1; + TableItem item; + int itemCount = headerTable.getItemCount(); + if (actualK >= itemCount) { + item = new TableItem(headerTable, SWT.NONE); + } else { + item = headerTable.getItem(actualK); + } + item.setText(i, value); + } + } + } + + } catch (IOException e) { + setErrorMessage(e.getMessage()); + } + } + + protected void validatePageComplete() { + if (model.isVertexImport()) + setPageComplete(model.getXCoordIndex() != -1 && model.getYCoordIndex() != -1 && model.getComponentMappingIndex() != -1); + else + setPageComplete(model.getStartXCoordIndex() != -1 && model.getStartYCoordIndex() != -1 && model.getEndXCoordIndex() != -1 && model.getEndYCoordIndex() != -1 && model.getComponentMappingIndex() != -1); + } + +}