--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gwt-client/src/main/java/org/dive4elements/river/client/client/ui/AbstractEpochPanel.java	Wed May 23 17:30:24 2018 +0200
@@ -0,0 +1,262 @@
+/** Copyright (C) 2017 by Bundesanstalt für Gewässerkunde
+ * Software engineering by
+ *  Björnsen Beratende Ingenieure GmbH
+ *  Dr. Schumacher Ingenieurbüro für Wasser und Umwelt
+ *
+ * This file is Free Software under the GNU AGPL (>=v3)
+ * and comes with ABSOLUTELY NO WARRANTY! Check out the
+ * documentation coming with Dive4Elements River for details.
+ */
+package org.dive4elements.river.client.client.ui;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.TreeSet;
+
+import org.dive4elements.river.client.client.ui.FromToTableHelperPanel.IColumnClickHandler;
+import org.dive4elements.river.client.shared.model.Data;
+import org.dive4elements.river.client.shared.model.DataItem;
+import org.dive4elements.river.client.shared.model.DataList;
+import org.dive4elements.river.client.shared.model.DefaultData;
+import org.dive4elements.river.client.shared.model.DefaultDataItem;
+
+import com.smartgwt.client.widgets.Canvas;
+import com.smartgwt.client.widgets.Label;
+import com.smartgwt.client.widgets.form.fields.TextItem;
+import com.smartgwt.client.widgets.grid.ListGrid;
+import com.smartgwt.client.widgets.grid.ListGridRecord;
+import com.smartgwt.client.widgets.layout.HLayout;
+import com.smartgwt.client.widgets.layout.VLayout;
+
+/**
+ * @author Domenico Nardi Tironi
+ *
+ */
+public abstract class AbstractEpochPanel extends AbstractUIProvider {
+
+    private static final long serialVersionUID = 1L;
+
+    protected enum Type {
+        singleMinMax, multi
+        // Type singleMinMax: nur eine Epoche kann gesetzt werden; minMax vorbelegt aus Datenquelle
+        // Type multi: mehrere epochs können eingegeben werden
+    }
+
+    private TextItem start;
+
+    private TextItem end;
+
+    private ListGrid elements;
+
+    private List<String> validInputs = new ArrayList<String>();
+
+    private final Type type;
+
+    public AbstractEpochPanel(final Type type) {
+        this.type = type;
+    }
+
+    protected abstract String getDatakey();
+
+    protected abstract Canvas createWidget(final DataList data);
+
+    private final void postCreate() {
+        switch (this.type) {
+        case singleMinMax:
+            final TreeSet<String> minMax = new TreeSet<String>(this.validInputs);
+            if (minMax.size() > 1) {
+                this.start.setValue(minMax.first());
+                this.end.setValue(minMax.last());
+            } else {
+                // TODO: THIS STATE IS INVALID; RETURN - es gibt keinen Mechanismus, der das verhindert; müsste
+                // im State davor passieren)
+            }
+            break;
+        case multi:
+            break; // do nothing
+        default:
+            throw new IllegalStateException();
+        }
+    }
+
+    protected final TextItem createStartInputItem(final String title) {
+        this.start = PanelHelper.createItem(title);
+        return this.start;
+    }
+
+    protected final TextItem createEndInputItem(final String title) {
+        this.end = PanelHelper.createItem(title);
+        return this.end;
+    }
+
+    protected final ListGrid createListGrid() {
+        this.elements = new ListGrid();
+        this.elements.setShowHeaderContextMenu(false);
+        this.elements.setCanReorderFields(false);
+        this.elements.setCanSort(false);
+        this.elements.setCanEdit(false);
+        return this.elements;
+    }
+
+    @Override
+    public final Canvas createOld(final DataList dataList) {
+        final HLayout layout = new HLayout();
+        layout.setWidth("400px");
+        final VLayout vLayout = new VLayout();
+        vLayout.setWidth(130);
+        final Label label = new Label(dataList.getLabel());
+        label.setWidth("200px");
+        label.setHeight(25);
+
+        final List<Data> items = dataList.getAll();
+        final Data str = getData(items, getDatakey());
+        final DataItem[] strItems = str.getItems();
+
+        final String[] pairs = strItems[0].getLabel().split(";");
+        for (final String pair : pairs) {
+            final Label dateLabel = new Label(pair.replace(",", " - "));
+            dateLabel.setHeight(20);
+            vLayout.addMember(dateLabel);
+        }
+        final Canvas back = getBackButton(dataList.getState());
+        layout.addMember(label);
+        layout.addMember(vLayout);
+        layout.addMember(back);
+
+        return layout;
+    }
+
+    @Override
+    public final Canvas create(final DataList data) {
+        final VLayout layout = new VLayout();
+        final Canvas submit = getNextButton();
+        final Canvas widget = createWidget(data);
+
+        layout.addMember(widget);
+        layout.addMember(submit);
+
+        final IColumnClickHandler fromHandler = createHandler(this.start);
+        final IColumnClickHandler toHandler = createHandler(this.end);
+
+        final FromToTableHelperPanel helper = new FromToTableHelperPanel(data, getDatakey(), this.MSG, fromHandler, toHandler);
+        this.validInputs = helper.getKeycolEntries();
+        final Canvas table = helper.getTable();
+
+        this.helperContainer.addMember(table);
+
+        postCreate();
+        return layout;
+    }
+
+    private final IColumnClickHandler createHandler(final TextItem field) {
+        final IColumnClickHandler handler = new IColumnClickHandler() {
+
+            @Override
+            public void columnClicked(final String value) {
+                field.setValue(value);
+            }
+        };
+        return handler;
+    }
+
+    /*
+     * Validate the epoch input. We do this here and not in an overridden
+     * validate method as we want to validate before an epoch is added
+     * to the list of epochs.
+     */
+    protected final boolean isValidEpoch(final String y1, final String y2) {
+        // First check that both are integer
+        // int iY1;
+        // int iY2;
+        final List<String> errors = new ArrayList<String>();
+        try {
+            // iY1 =
+            Integer.parseInt(y1);
+        }
+        catch (final NumberFormatException e) {
+            errors.add(this.MSG.wrongFormat() + ": " + y1);
+        }
+        try {
+            // iY2 =
+            Integer.parseInt(y2);
+        }
+        catch (final NumberFormatException e) {
+            errors.add(this.MSG.wrongFormat() + ": " + y2);
+        }
+        if (!errors.isEmpty()) {
+            showErrors(errors);
+            return false;
+        }
+        boolean startIsGood = false;
+        boolean endIsGood = false;
+        for (final String validYear : this.validInputs) {
+            if (startIsGood || y1.equals(validYear)) {
+                startIsGood = true;
+            }
+            if (endIsGood || y2.equals(validYear)) {
+                endIsGood = true;
+            }
+            if (startIsGood && endIsGood) {
+                break;
+            }
+            /*
+             * alternative check if data lies in between
+             * int aYear = Integer.parseInt(validYear);
+             * if (aYear >= iY1 && aYear <= iY2) {
+             * isGood = true;
+             * break;
+             * }
+             */
+        }
+        if (!startIsGood) {
+            String tmp = this.MSG.no_data_for_year();
+            tmp = tmp.replace("$1", y1);
+            errors.add(tmp);
+        }
+        if (!endIsGood) {
+            String tmp = this.MSG.no_data_for_year();
+            tmp = tmp.replace("$1", y2);
+            errors.add(tmp);
+        }
+        if (!errors.isEmpty()) {
+            showErrors(errors);
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    protected final Data[] getData() {
+        final List<Data> data = new ArrayList<Data>();
+        switch (this.type) {
+
+        case singleMinMax:
+            data.add(buildResult(this.start.getValueAsString(), this.end.getValueAsString()));
+
+            break;
+        case multi:
+            final ListGridRecord[] lgr = this.elements.getRecords();
+            if (lgr.length == 0) {
+                return new Data[0];
+            }
+            for (final ListGridRecord element : lgr) {
+                data.add(buildResult(element.getAttribute("from"), element.getAttribute("to")));
+            }
+            break;
+        default:
+            throw new IllegalStateException();
+        }
+        return data.toArray(new Data[data.size()]);
+    }
+
+    private final Data buildResult(final String startStr, final String endStr) {
+        final StringBuilder builder = new StringBuilder();
+        builder.append(startStr);
+        builder.append(",");
+        builder.append(endStr);
+        builder.append(";");
+        final DataItem item = new DefaultDataItem(getDatakey(), null, builder.toString());
+        return new DefaultData(getDatakey(), null, null, new DataItem[] { item });
+    }
+
+}