--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/flys-client/src/main/java/org/dive4elements/river/client/client/ui/ParameterList.java	Thu Apr 25 12:31:32 2013 +0200
@@ -0,0 +1,1023 @@
+package de.intevation.flys.client.client.ui;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.user.client.rpc.AsyncCallback;
+
+import com.smartgwt.client.types.VerticalAlignment;
+import com.smartgwt.client.types.VisibilityMode;
+import com.smartgwt.client.util.SC;
+import com.smartgwt.client.widgets.Canvas;
+import com.smartgwt.client.widgets.layout.HLayout;
+import com.smartgwt.client.widgets.layout.SectionStack;
+import com.smartgwt.client.widgets.layout.SectionStackSection;
+import com.smartgwt.client.widgets.layout.VLayout;
+import com.smartgwt.client.widgets.tab.Tab;
+import com.smartgwt.client.widgets.tab.events.TabSelectedHandler;
+
+import de.intevation.flys.client.client.Config;
+import de.intevation.flys.client.client.FLYS;
+import de.intevation.flys.client.client.FLYSConstants;
+import de.intevation.flys.client.client.event.AdvanceHandler;
+import de.intevation.flys.client.client.event.CollectionChangeEvent;
+import de.intevation.flys.client.client.event.CollectionChangeHandler;
+import de.intevation.flys.client.client.event.HasParameterChangeHandler;
+import de.intevation.flys.client.client.event.HasStepBackHandlers;
+import de.intevation.flys.client.client.event.HasStepForwardHandlers;
+import de.intevation.flys.client.client.event.OutputModesChangeEvent;
+import de.intevation.flys.client.client.event.OutputModesChangeHandler;
+import de.intevation.flys.client.client.event.ParameterChangeEvent;
+import de.intevation.flys.client.client.event.ParameterChangeHandler;
+import de.intevation.flys.client.client.event.StepBackEvent;
+import de.intevation.flys.client.client.event.StepBackHandler;
+import de.intevation.flys.client.client.event.StepForwardEvent;
+import de.intevation.flys.client.client.event.StepForwardHandler;
+import de.intevation.flys.client.client.services.AdvanceService;
+import de.intevation.flys.client.client.services.AdvanceServiceAsync;
+import de.intevation.flys.client.client.services.ArtifactService;
+import de.intevation.flys.client.client.services.ArtifactServiceAsync;
+import de.intevation.flys.client.client.services.ReportService;
+import de.intevation.flys.client.client.services.ReportServiceAsync;
+import de.intevation.flys.client.client.services.StepForwardService;
+import de.intevation.flys.client.client.services.StepForwardServiceAsync;
+import de.intevation.flys.client.client.ui.stationinfo.GaugePanel;
+import de.intevation.flys.client.client.ui.stationinfo.InfoPanel;
+import de.intevation.flys.client.client.ui.stationinfo.MeasurementStationPanel;
+import de.intevation.flys.client.shared.model.Artifact;
+import de.intevation.flys.client.shared.model.ArtifactDescription;
+import de.intevation.flys.client.shared.model.Collection;
+import de.intevation.flys.client.shared.model.Data;
+import de.intevation.flys.client.shared.model.DataItem;
+import de.intevation.flys.client.shared.model.DataList;
+import de.intevation.flys.client.shared.model.DefaultData;
+import de.intevation.flys.client.shared.model.DefaultDataItem;
+import de.intevation.flys.client.shared.model.ExportMode;
+import de.intevation.flys.client.shared.model.FixAnalysisArtifact;
+import de.intevation.flys.client.shared.model.MINFOArtifact;
+import de.intevation.flys.client.shared.model.OutputMode;
+import de.intevation.flys.client.shared.model.ReportMode;
+import de.intevation.flys.client.shared.model.River;
+import de.intevation.flys.client.shared.model.WINFOArtifact;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+
+public class ParameterList
+extends      Tab
+implements   StepBackHandler, StepForwardHandler, ParameterChangeHandler,
+             HasParameterChangeHandler, CollectionChangeHandler,
+             OutputModesChangeHandler, AdvanceHandler
+{
+    private static final long serialVersionUID = 5204784727239299980L;
+
+    public static final String STYLENAME_OLD_PARAMETERS = "oldParameters";
+
+    /** The message class that provides i18n strings.*/
+    protected FLYSConstants MSG = GWT.create(FLYSConstants.class);
+
+    /** The ArtifactService used to communicate with the Artifact server. */
+    protected ArtifactServiceAsync artifactService =
+        GWT.create(ArtifactService.class);
+
+    /** The StepForwardService used to put data into an existing artifact. */
+    protected StepForwardServiceAsync forwardService =
+        GWT.create(StepForwardService.class);
+
+    /** The StepForwardService used to put data into an existing artifact. */
+    protected AdvanceServiceAsync advanceService =
+        GWT.create(AdvanceService.class);
+
+
+    protected ReportServiceAsync reportService =
+        GWT.create(ReportService.class);
+
+
+    /** The list of ParameterizationChangeHandler.*/
+    protected List<ParameterChangeHandler> parameterHandlers;
+
+    protected FLYS flys;
+
+    protected CollectionView cView;
+
+    protected Artifact artifact;
+
+    protected List<DataList> old;
+    protected Map<String, Canvas> oldStorage;
+    protected DataList   current;
+
+    protected UIProvider uiProvider;
+
+    protected VLayout topLayout;
+    protected VLayout oldItems;
+    protected VLayout currentItems;
+    protected VLayout exportModes;
+    protected VLayout report;
+    protected VLayout helperPanel;
+    protected VLayout tablePanel;
+    protected InfoPanel infoPanel;
+    protected Canvas  reportPanel;
+
+    private SectionStack stack;
+
+    public ParameterList(FLYS flys, CollectionView cView, String title) {
+        super(title);
+
+        this.cView = cView;
+        this.flys  = flys;
+
+        parameterHandlers = new ArrayList<ParameterChangeHandler>();
+        old               = new ArrayList<DataList>();
+        oldStorage        = new TreeMap<String, Canvas>();
+        topLayout         = new VLayout();
+        oldItems          = new VLayout();
+        currentItems      = new VLayout();
+        exportModes       = new VLayout();
+        report            = new VLayout();
+
+        addParameterChangeHandler(this);
+
+        init();
+    }
+
+
+    public ParameterList(
+        FLYS           flys,
+        CollectionView cView,
+        String         title,
+        Artifact       artifact)
+    {
+        super(title);
+
+        this.cView    = cView;
+        this.flys     = flys;
+        this.artifact = artifact;
+
+        parameterHandlers = new ArrayList<ParameterChangeHandler>();
+        old               = new ArrayList<DataList>();
+        oldStorage        = new TreeMap<String, Canvas>();
+        topLayout         = new VLayout();
+        oldItems          = new VLayout();
+        currentItems      = new VLayout();
+        exportModes       = new VLayout();
+        report            = new VLayout();
+
+        init();
+
+        addParameterChangeHandler(this);
+
+        setArtifact(artifact, false);
+    }
+
+
+    protected void init() {
+        HLayout rootLayout = new HLayout();
+        rootLayout.setMembersMargin(20);
+
+        VLayout left = new VLayout();
+
+        if (old == null || old.size() == 0) {
+            oldItems.setHeight(1);
+        }
+
+        oldItems.setMembersMargin(10);
+        oldItems.setStyleName(STYLENAME_OLD_PARAMETERS);
+        currentItems.setAlign(VerticalAlignment.TOP);
+
+        left.setMembersMargin(20);
+        left.setWidth(300);
+
+        left.addMember(oldItems);
+        left.addMember(currentItems);
+        left.addMember(exportModes);
+        left.addMember(report);
+
+        reportPanel = new Canvas();
+        reportPanel.setHeight("*");
+        report.addMember(reportPanel);
+
+        rootLayout.addMember(left);
+        rootLayout.addMember(createSectionStack());
+
+        topLayout.addMember(rootLayout);
+        if (artifact == null) {
+            Canvas moduleSelection = renderNew();
+            moduleSelection.setLayoutAlign(VerticalAlignment.TOP);
+            currentItems.addMember(moduleSelection);
+        }
+
+        setPane(topLayout);
+    }
+
+
+    protected SectionStack createSectionStack() {
+        stack = new SectionStack();
+        stack.setHeight100();
+        stack.setCanResizeSections(true);
+        stack.setVisibilityMode(VisibilityMode.MULTIPLE);
+
+        // This canvas is used to render helper widgets.
+        final SectionStackSection helperSection = new SectionStackSection();
+        helperSection.setExpanded(false);
+        helperSection.setTitle(MSG.helperPanelTitle());
+        helperPanel = new VLayout() {
+            @Override
+            public void addMember(Canvas component) {
+                super.addMember(component);
+                stack.expandSection(helperSection.getID());
+            }
+
+            @Override
+            public void removeMembers(Canvas[] components) {
+                super.removeMembers(components);
+                helperSection.setExpanded(false);
+            }
+        };
+        helperPanel.setWidth100();
+        helperPanel.setHeight100();
+        helperSection.setItems(helperPanel);
+
+        // This canvas is used to render calculation results.
+        final SectionStackSection tableSection = new SectionStackSection();
+        tableSection.setExpanded(false);
+        tableSection.setTitle(MSG.calcTableTitle());
+        tablePanel = new VLayout() {
+            @Override
+            public void addMember(Canvas component) {
+                super.addMember(component);
+                tableSection.setExpanded(true);
+            }
+
+            @Override
+            public void removeMembers(Canvas[] components) {
+                super.removeMembers(components);
+                tableSection.setExpanded(false);
+            }
+        };
+        tablePanel.setHeight100();
+        tablePanel.setWidth100();
+        tableSection.setItems(tablePanel);
+
+        stack.setSections(helperSection, tableSection);
+
+        return stack;
+    }
+
+
+    /** Sets and forwards artifact. */
+    protected void setArtifact(Artifact artifact) {
+        setArtifact(artifact, true);
+    }
+
+
+    protected void setArtifact(Artifact artifact, boolean forward) {
+        Artifact tmp  = this.artifact;
+        this.artifact = artifact;
+
+        if (forward) {
+            fireParameterChangeEvent(
+                tmp, this.artifact, ParameterChangeEvent.Type.FORWARD);
+        }
+        else {
+            fireParameterChangeEvent(
+                tmp, this.artifact, ParameterChangeEvent.Type.BACK);
+        }
+    }
+
+
+    /**
+     * This method registers a new ParameterChangeHandler.
+     *
+     * @param handler The new ParameterChangeHandler.
+     */
+    @Override
+    public void addParameterChangeHandler(ParameterChangeHandler handler) {
+        if (handler != null) {
+            parameterHandlers.add(handler);
+        }
+    }
+
+
+    /**
+     * This method calls the <code>onParameterChange()</code> method of all
+     * registered ParameterChangeHandler.
+     */
+    protected void fireParameterChangeEvent(
+        Artifact old,
+        Artifact newArt,
+        ParameterChangeEvent.Type type)
+    {
+        ParameterChangeEvent e = new ParameterChangeEvent(old, newArt, type);
+
+        for (ParameterChangeHandler handler: parameterHandlers) {
+            handler.onParameterChange(e);
+        }
+    }
+
+
+    /**
+     * This method creates a Canvas displaying the plugins of FLYS combined with
+     * a widget to select a river.
+     *
+     * @return a Canvas that displays the supported plugins and rivers of FLYS.
+     */
+    protected Canvas renderNew() {
+        River[] rivers   = flys.getRivers();
+        DataItem[] items = new DataItem[rivers.length];
+
+        int i = 0;
+        for (River river: rivers) {
+            String name = river.getName();
+            items[i++]  = new DefaultDataItem(name, null, name);
+        }
+
+        Data data = new DefaultData(
+            "river",
+            MSG.river_selection(),
+            null,
+            items);
+
+        LinkSelection widget           = new LinkSelection();
+        HasStepForwardHandlers handler = widget;
+
+        widget.setContainer(helperPanel);
+
+        handler.addStepForwardHandler(new StepForwardHandler() {
+            private static final long serialVersionUID = -6210719844707004860L;
+
+            @Override
+            public void onStepForward(StepForwardEvent event) {
+                lockUI();
+                Data[] data = event.getData();
+
+                DataItem[] moduleItems = data[0].getItems();
+                DataItem[] riversItems = data[1].getItems();
+
+                String module = moduleItems[0].getStringValue();
+                String river  = riversItems[0].getStringValue();
+
+                if (module == null || river == null) {
+                    GWT.log("ParameterList.renderNew(): module == null || river == null");
+                    unlockUI();
+                    return;
+                }
+
+                String newTitle = MSG.getString(module);
+                setTitle(newTitle);
+
+                Config config       = Config.getInstance();
+                final String locale = config.getLocale();
+
+                final Data[] feedData = new Data[] { data[1] };
+
+                artifactService.create(
+                    locale, module.toLowerCase(), null,
+                    new AsyncCallback<Artifact>() {
+                        @Override
+                        public void onFailure(Throwable caught) {
+                            unlockUI();
+                            GWT.log("Could not create the new artifact.");
+                            SC.warn(FLYS.getExceptionString(MSG, caught));
+                        }
+
+                        @Override
+                        public void onSuccess(Artifact artifact) {
+                            GWT.log("Successfully created a new artifact.");
+
+                            forwardService.go(locale, artifact, feedData,
+                            new AsyncCallback<Artifact>() {
+                                @Override
+                                public void onFailure(Throwable caught) {
+                                    unlockUI();
+                                    GWT.log("Could not feed the artifact.");
+                                    SC.warn(caught.getMessage());
+                                }
+
+                                @Override
+                                public void onSuccess(Artifact artifact) {
+                                    GWT.log("Successfully feed the artifact.");
+                                    old.clear();
+                                    cView.addArtifactToCollection(artifact);
+                                    setArtifact(artifact);
+                                    unlockUI();
+                                }
+                            });
+                        }
+                });
+            }
+        });
+
+        DataList list = new DataList();
+        list.add(data);
+
+        return widget.create(list);
+    }
+
+
+    protected void clearOldData() {
+        old.clear();
+    }
+
+
+    public void addOldData(DataList old) {
+        addOldData(old, true);
+    }
+
+
+    public void addOldData(DataList old, boolean redraw) {
+        if (old != null) {
+            this.old.add(old);
+        }
+
+        refreshOld(redraw);
+    }
+
+
+    public void addOldDatas(DataList[] old) {
+        addOldDatas(old, true);
+    }
+
+
+    public void addOldDatas(DataList[] old, boolean redraw) {
+        if (old != null && old.length > 0) {
+            for (DataList o: old) {
+                if (o == null) {
+                    continue;
+                }
+
+                if (!exists(o)) {
+                    GWT.log("Data '" + o.getLabel() + "' is new.");
+                    addOldData(o, false);
+                }
+            }
+
+            if (redraw) {
+                addOldData(null, true);
+            }
+
+            return;
+        }
+
+        addOldData(null, true);
+    }
+
+
+    public boolean exists(DataList data) {
+        if (data == null) {
+            return false;
+        }
+
+        String stateName = data.getState();
+
+        for (DataList o: old) {
+            if (stateName.equals(o.getState())) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+
+    public void setCurrentData(DataList current, UIProvider uiProvider) {
+        this.current    = current;
+        this.uiProvider = uiProvider;
+
+        refreshCurrent();
+    }
+
+
+    public void refreshOld(boolean redrawAll) {
+        if (redrawAll) {
+            refreshAllOld();
+        }
+        else {
+            DataList dataList = old.get(old.size()-1);
+            String   state    = dataList.getState();
+
+            if (oldStorage.get(state) == null) {
+                String     provider   = dataList.getUIProvider();
+                UIProvider uiprovider = UIProviderFactory.getProvider(
+                    provider,
+                    flys.getCurrentUser());
+                ((HasStepBackHandlers) uiprovider).addStepBackHandler(this);
+
+                Canvas c = uiprovider.createOld(dataList);
+                if (c != null) {
+                    oldStorage.put(dataList.getState(), c);
+                    oldItems.addMember(c);
+                }
+            }
+        }
+
+        updateOldHeight();
+    }
+
+
+    protected void refreshAllOld() {
+        List<String> not = new ArrayList<String>();
+
+        for (DataList data: old) {
+            String state = data.getState();
+
+            Canvas c = oldStorage.get(state);
+
+            if (c != null) {
+                not.add(state);
+            }
+        }
+
+        Map<String, Canvas> newOld = new TreeMap<String, Canvas>();
+
+        Set<Map.Entry<String, Canvas>> entries = oldStorage.entrySet();
+        for (Map.Entry<String, Canvas> entry: entries) {
+            String state = entry.getKey();
+            Canvas value = entry.getValue();
+
+            if (not.indexOf(state) < 0) {
+                oldItems.removeMember(value);
+            }
+            else {
+                newOld.put(state, value);
+            }
+        }
+
+        oldStorage = newOld;
+    }
+
+
+    protected void updateOldHeight() {
+        int minHeight = oldItems.getMinHeight();
+        if (minHeight <= 20) {
+            oldItems.setHeight(20);
+        }
+        else {
+            oldItems.setHeight(minHeight);
+        }
+    }
+
+
+    /**
+     * This method refreshes the part displaying the data of the current state.
+     * The UI is created using the UIProvider stored in the Data object.
+     */
+    public void refreshCurrent() {
+        currentItems.removeMembers(currentItems.getMembers());
+
+        if (current != null && uiProvider != null) {
+            Canvas c = uiProvider.create(current);
+            Canvas h = uiProvider.createHelpLink(current, null);
+
+            HLayout wrapper = new HLayout();
+            wrapper.addMember(h);
+            wrapper.addMember(c);
+
+            currentItems.addMember(wrapper);
+        }
+        else if (uiProvider != null) {
+            Canvas c = uiProvider.create(null);
+            c.setLayoutAlign(VerticalAlignment.TOP);
+
+            currentItems.addMember(c);
+        }
+        else {
+            currentItems.setHeight(1);
+        }
+
+        Canvas[] members = currentItems.getMembers();
+        if (members == null || members.length == 0) {
+            currentItems.setHeight(1);
+        }
+        else {
+            int height = 0;
+
+            for (Canvas member: members) {
+                height += member.getHeight();
+            }
+
+            currentItems.setHeight(height);
+        }
+    }
+
+
+    /**
+     * This method is called if the user clicks on the 'next' button to advance
+     * to the next state.
+     *
+     * @param event The StepForwardEvent.
+     */
+    @Override
+    public void onStepForward(StepForwardEvent event) {
+        GWT.log("CollectionView - onStepForward()");
+        lockUI();
+
+        Config config = Config.getInstance();
+        String locale = config.getLocale();
+
+        forwardService.go(locale, artifact, event.getData(),
+            new AsyncCallback<Artifact>() {
+                @Override
+                public void onFailure(Throwable caught) {
+                    unlockUI();
+                    GWT.log("Could not feed the artifact.");
+                    SC.warn(FLYS.getExceptionString(MSG, caught));
+                }
+
+                @Override
+                public void onSuccess(Artifact artifact) {
+                    GWT.log("Successfully feed the artifact.");
+                    old.clear();
+
+                    setArtifact(artifact, true);
+                    unlockUI();
+                }
+        });
+    }
+
+
+    /**
+     * This method is used to remove all old items from this list after the user
+     * has clicked the step back button.
+     *
+     * @param e The StepBackEvent that holds the identifier of the target state.
+     */
+    @Override
+    public void onStepBack(StepBackEvent e) {
+        lockUI();
+        final String target    = e.getTarget();
+
+        Config config          = Config.getInstance();
+        final String locale    = config.getLocale();
+
+        advanceService.advance(locale, artifact, target,
+            new AsyncCallback<Artifact>() {
+                @Override
+                public void onFailure(Throwable caught) {
+                    unlockUI();
+                    GWT.log("Could not go back to '" + target + "'");
+                    SC.warn(FLYS.getExceptionString(MSG, caught));
+                }
+
+                @Override
+                public void onSuccess(Artifact artifact) {
+                    GWT.log("Successfully step back to '" + target + "'");
+
+                    old.clear();
+
+                    setArtifact(artifact, false);
+                    unlockUI();
+                }
+            }
+        );
+    }
+
+
+    @Override
+    public void onAdvance(final String target) {
+        Config config          = Config.getInstance();
+        final String locale    = config.getLocale();
+
+        advanceService.advance(locale, artifact, target,
+            new AsyncCallback<Artifact>() {
+                @Override
+                public void onFailure(Throwable caught) {
+                    GWT.log("Could not go to '" + target + "'");
+                    SC.warn(FLYS.getExceptionString(MSG, caught));
+                }
+
+                @Override
+                public void onSuccess(Artifact artifact) {
+                    GWT.log("Successfully advanced to '" + target + "'");
+
+                    old.clear();
+
+                    setArtifact(artifact, true);
+                }
+            }
+        );
+    }
+
+
+    /**
+     * Implements the onCollectionChange() method to do update the GUI after the
+     * parameterization has changed.
+     *
+     * @param event The ParameterChangeEvent.
+     */
+    @Override
+    public void onParameterChange(ParameterChangeEvent event) {
+        GWT.log("ParameterList.onParameterChange");
+
+        Canvas[] c = helperPanel.getMembers();
+        if (c != null && c.length > 0) {
+            helperPanel.removeMembers(c);
+        }
+
+        Artifact art             = event.getNewValue();
+        ArtifactDescription desc = art.getArtifactDescription();
+
+        DataList currentData = desc.getCurrentData();
+        if (currentData != null) {
+            // the user has to enter some attributes
+            String uiProvider   = currentData.getUIProvider();
+            UIProvider provider = UIProviderFactory.getProvider(
+                uiProvider,
+                flys.getCurrentUser());
+
+            provider.setContainer(helperPanel);
+            provider.setArtifact(art);
+            provider.setCollection(cView.getCollection());
+            provider.setParameterList(this);
+
+            ((HasStepForwardHandlers) provider).addStepForwardHandler(this);
+            ((HasStepBackHandlers) provider).addStepBackHandler(this);
+
+            setCurrentData(currentData, provider);
+        }
+        else {
+            String[] reachable = desc.getReachableStates();
+            if (reachable != null && reachable.length > 0) {
+                // We have reached a final state with the option to step to
+                // further to a next state. But in the current state, no user
+                // data is required.
+                UIProvider ui = UIProviderFactory.getProvider("continue", null);
+                ui.setArtifact(art);
+                ui.setCollection(cView.getCollection());
+                ui.setParameterList(this);
+
+                ((ContinuePanel) ui).addAdvanceHandler(this);
+
+                setCurrentData(null, ui);
+            }
+            else {
+                // we have reached a final state with no more user input
+                setCurrentData(null, null);
+            }
+        }
+        if (art instanceof WINFOArtifact
+                || art instanceof FixAnalysisArtifact) {
+            createGaugePanel();
+            renderInfo(desc.getRiver(), desc.getOldData());
+        }
+        else if (art instanceof MINFOArtifact) {
+            createMeasurementStationPanel();
+            renderInfo(desc.getRiver(), desc.getOldData());
+        }
+        else {
+            removeInfoPanel();
+        }
+
+        addOldDatas(
+            desc.getOldData(),
+            event.getType() == ParameterChangeEvent.Type.BACK);
+    }
+
+
+    @Override
+    public void onCollectionChange(CollectionChangeEvent event) {
+        Collection                 c = event.getNewValue();
+        Map<String, OutputMode> outs = c.getOutputModes();
+        Set<String>             keys = outs.keySet();
+
+        OutputMode[] outputs = new OutputMode[outs.size()];
+
+        int idx = 0;
+        for (String outname: keys) {
+            outputs[idx++] = outs.get(outname);
+        }
+
+        updateExportModes(c, getExportModes(outputs));
+        updateReportModes(c, getReportModes(outputs));
+    }
+
+
+    @Override
+    public void onOutputModesChange(OutputModesChangeEvent event) {
+
+        Collection c = cView.getCollection();
+
+        if (c != null) {
+            OutputMode [] outs = event.getOutputModes();
+            updateExportModes(c, getExportModes(outs));
+            updateReportModes(c, getReportModes(outs));
+        }
+    }
+
+
+    protected List<ReportMode> getReportModes(OutputMode [] outs) {
+
+        List<ReportMode> reports = new ArrayList<ReportMode>();
+
+        if (outs == null || outs.length == 0) {
+            return reports;
+        }
+
+        for (OutputMode out: outs) {
+            if (out instanceof ReportMode) {
+                reports.add((ReportMode)out);
+            }
+        }
+
+        return reports;
+    }
+
+
+    protected List<ExportMode> getExportModes(OutputMode[] outs) {
+        List<ExportMode> exports = new ArrayList<ExportMode>();
+
+        if (outs == null || outs.length == 0) {
+            return exports;
+        }
+
+        for (OutputMode out: outs) {
+            if (out instanceof ExportMode) {
+                exports.add((ExportMode) out);
+            }
+        }
+
+        return exports;
+    }
+
+
+    protected void updateExportModes(Collection c, List<ExportMode> exports) {
+        int num = exports != null ? exports.size() : 0;
+        GWT.log("Update export modes: " + num);
+
+        exportModes.removeMembers(exportModes.getMembers());
+
+        if (exports.size() > 0) {
+            exportModes.addMember(new ExportPanel(c, exports));
+        }
+        else {
+            exportModes.setHeight(1);
+        }
+    }
+
+    protected void updateReportModes(Collection c, List<ReportMode> reports) {
+        int num = reports != null ? reports.size() : 0;
+        GWT.log("Update report modes: " + num);
+
+        if (num == 0) {
+            reportPanel.setContents("");
+            return;
+        }
+
+        Config config = Config.getInstance();
+        String locale = config.getLocale();
+
+        String cid = c.identifier();
+
+        for (ReportMode report: reports) {
+            GWT.log("report '" + report.toString() + "'");
+
+            reportService.report(cid, locale, report.getName(),
+                new AsyncCallback<String>() {
+                    @Override
+                    public void onFailure(Throwable caught) {
+                        SC.warn(FLYS.getExceptionString(MSG, caught));
+                    }
+
+                    @Override
+                    public void onSuccess(String msg) {
+                        setReportMessage(msg);
+                    }
+                });
+        }
+    }
+
+
+    /** Sets content of reportPanel. */
+    protected void setReportMessage(String msg) {
+        GWT.log("returned from service: " + msg);
+        if (msg == null) {
+            msg = "";
+        }
+        reportPanel.setContents(msg);
+    }
+
+
+    /**
+     * Adds a table to the parameterlist to show calculated data.
+     *
+     * @param table The table data panel.
+     */
+    public void setTable(TableDataPanel table) {
+        removeTable();
+
+        Canvas c = table.create();
+        c.setHeight100();
+        c.setWidth100();
+
+        tablePanel.addMember(c);
+    }
+
+
+    public boolean hasTable() {
+        Canvas[] members = tablePanel.getMembers();
+
+        return members != null && members.length > 0;
+    }
+
+
+    /**
+     * Removes the table from the parameter list.
+     */
+    public void removeTable() {
+        Canvas[] members = tablePanel.getMembers();
+
+        if (members != null && members.length > 0) {
+            tablePanel.removeMembers(members);
+        }
+    }
+
+
+    public void registerCollectionViewTabHandler(TabSelectedHandler tsh) {
+        this.cView.registerTabHandler(tsh);
+    }
+
+
+    protected void lockUI() {
+        cView.lockUI();
+    }
+
+
+    protected void unlockUI() {
+        cView.unlockUI();
+    }
+
+
+    private void createGaugePanel() {
+        GWT.log("ParameterList - createGaugePanel");
+        if (infoPanel == null) {
+            infoPanel = new GaugePanel(flys);
+            infoPanel.setWidth100();
+            infoPanel.setHeight100();
+        }
+    }
+
+    private void createMeasurementStationPanel() {
+        GWT.log("ParameterList - createMeasurementStationPanel");
+        if (infoPanel == null) {
+            infoPanel = new MeasurementStationPanel(flys);
+            infoPanel.setWidth100();
+            infoPanel.setHeight100();
+        }
+    }
+
+    private void showInfoPanel() {
+        GWT.log("ParameterList - showInfoPanel");
+
+        /* Don't add InfoPanel twice */
+        SectionStackSection exists = stack.getSection(InfoPanel.SECTION_ID);
+        if (exists == null) {
+            stack.addSection(infoPanel.getSection(), 0);
+        }
+
+        infoPanel.show();
+    }
+
+    private void hideInfoPanel() {
+        GWT.log("ParameterList - hideInfoPanel");
+
+        if (infoPanel != null) {
+            infoPanel.hide();
+        }
+    }
+
+    private void removeInfoPanel() {
+        GWT.log("ParameterList - removeInfoPanel");
+        SectionStackSection exists = stack.getSection(InfoPanel.SECTION_ID);
+        if (exists != null) {
+            stack.removeSection(InfoPanel.SECTION_ID);
+        }
+    }
+
+
+    private void renderInfo(String river, DataList[] data) {
+        GWT.log("ParameterList - renderInfo");
+
+        if (river != null) {
+            showInfoPanel();
+            infoPanel.setRiver(river);
+            infoPanel.setData(data);
+        }
+        else {
+            GWT.log("ParameterList - renderInfo no river");
+            hideInfoPanel();
+        }
+    }
+
+    /**
+     * Allow to close all folds of the info panel.
+     * This is necessary e.g. if a csv result should be shown.
+     */
+    public void contractInfoPanel() {
+        if (infoPanel != null) {
+            infoPanel.contract();
+        }
+    }
+
+}
+// vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8 :