[Tutti-commits] 04/04: En avant la musique... création de modèles et controleurs...

This is an automated email from the git hooks/post-receive script. New commit to branch feature/8245 in repository tutti. See https://gitlab.nuiton.org/codelutin/tutti.git commit 278f70357eabf2563a71be3f617ab0c95efcf6ab Author: Tony CHEMIT <chemit@codelutin.com> Date: Fri Apr 15 09:52:50 2016 +0200 En avant la musique... création de modèles et controleurs... --- .../accidental/AccidentalBatchUIHandler.java | 2 +- .../SamplingCodeCellEditor.java | 2 + .../catches/species/edit/SpeciesBatchRowModel.java | 2 +- .../species/edit/SpeciesBatchUIHandler.java | 2 +- .../frequency/AverageWeightsHistogramHandler.java | 156 ++ .../frequency/AverageWeightsHistogramModel.java | 120 ++ .../frequency/FrequenciesHistogramHandler.java | 166 ++ .../frequency/FrequenciesHistogramModel.java | 113 ++ .../IndividualObservationBatchRowModel.java | 2 +- .../IndividualObservationBatchTableHandler.java | 665 ++++++++ .../IndividualObservationBatchTableModel.java | 67 +- .../frequency/IndividualObservationUICache.java | 1 - .../frequency/SpeciesFrequencyCellComponent.java | 1 - .../frequency/SpeciesFrequencyLogRowModel.java | 1 - .../frequency/SpeciesFrequencyTableModel.java | 111 +- .../species/frequency/SpeciesFrequencyUI.jaxx | 2 +- .../frequency/SpeciesFrequencyUIHandler.java | 1651 +++++++++++--------- .../species/frequency/SpeciesFrequencyUIModel.java | 107 +- .../actions/ApplySpeciesFrequencyRafaleAction.java | 4 +- .../frequency/actions/DeleteSampleCodeAction.java | 4 +- .../DeleteSpeciesFrequencyLogRowAction.java | 2 +- .../frequency/actions/EditSampleCodeAction.java | 4 +- .../ImportMultiPostSpeciesSupportAction.java | 2 +- .../frequency/actions/RemoveObservationAction.java | 4 +- 24 files changed, 2303 insertions(+), 888 deletions(-) diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/accidental/AccidentalBatchUIHandler.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/accidental/AccidentalBatchUIHandler.java index b2df417..54725bc 100644 --- a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/accidental/AccidentalBatchUIHandler.java +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/accidental/AccidentalBatchUIHandler.java @@ -38,7 +38,7 @@ import fr.ifremer.tutti.ui.swing.content.operation.catches.EditCatchesUI; import fr.ifremer.tutti.ui.swing.content.operation.catches.EditCatchesUIHandler; import fr.ifremer.tutti.ui.swing.content.operation.catches.EditCatchesUIModel; import fr.ifremer.tutti.ui.swing.content.operation.catches.accidental.create.CreateAccidentalBatchUIModel; -import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.IndividualObservationBatchTableModel; +import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.IndividualObservationBatchTableModel; import fr.ifremer.tutti.ui.swing.util.TuttiBeanMonitor; import fr.ifremer.tutti.ui.swing.util.TuttiUI; import fr.ifremer.tutti.ui.swing.util.TuttiUIUtil; diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/individualobservation/SamplingCodeCellEditor.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/individualobservation/SamplingCodeCellEditor.java index 7cfacdc..69e228f 100644 --- a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/individualobservation/SamplingCodeCellEditor.java +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/individualobservation/SamplingCodeCellEditor.java @@ -25,6 +25,8 @@ package fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservatio import com.google.common.base.Preconditions; import fr.ifremer.tutti.service.sampling.CruiseSamplingCache; import fr.ifremer.tutti.ui.swing.TuttiUIContext; +import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.IndividualObservationBatchRowModel; +import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.IndividualObservationBatchTableModel; import fr.ifremer.tutti.ui.swing.util.TuttiUI; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/edit/SpeciesBatchRowModel.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/edit/SpeciesBatchRowModel.java index 950cc31..6d861f2 100644 --- a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/edit/SpeciesBatchRowModel.java +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/edit/SpeciesBatchRowModel.java @@ -37,7 +37,7 @@ import fr.ifremer.tutti.persistence.entities.data.SpeciesBatchs; import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; import fr.ifremer.tutti.persistence.entities.referential.Species; import fr.ifremer.tutti.type.WeightUnit; -import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.IndividualObservationBatchRowModel; +import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.IndividualObservationBatchRowModel; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.SpeciesFrequencyRowModel; import fr.ifremer.tutti.ui.swing.util.AbstractTuttiBeanUIModel; import fr.ifremer.tutti.ui.swing.util.attachment.AttachmentModelAware; diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/edit/SpeciesBatchUIHandler.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/edit/SpeciesBatchUIHandler.java index 096058c..3a0f650 100644 --- a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/edit/SpeciesBatchUIHandler.java +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/edit/SpeciesBatchUIHandler.java @@ -42,7 +42,7 @@ import fr.ifremer.tutti.persistence.entities.referential.Species; import fr.ifremer.tutti.service.ValidationService; import fr.ifremer.tutti.type.WeightUnit; import fr.ifremer.tutti.ui.swing.content.operation.catches.AbstractTuttiBatchTableUIHandler; -import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.IndividualObservationBatchRowModel; +import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.IndividualObservationBatchRowModel; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.SpeciesOrBenthosBatchUISupport; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.create.CreateSpeciesBatchUIModel; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.SpeciesFrequencyCellComponent; diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/AverageWeightsHistogramHandler.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/AverageWeightsHistogramHandler.java new file mode 100644 index 0000000..bf610c2 --- /dev/null +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/AverageWeightsHistogramHandler.java @@ -0,0 +1,156 @@ +package fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency; + +import fr.ifremer.tutti.ui.swing.util.TuttiNumberTickUnitSource; +import fr.ifremer.tutti.util.Units; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.jfree.chart.ChartFactory; +import org.jfree.chart.ChartPanel; +import org.jfree.chart.JFreeChart; +import org.jfree.chart.axis.NumberTickUnitSource; +import org.jfree.chart.axis.ValueAxis; +import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer; + +import javax.swing.JFrame; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.beans.PropertyChangeEvent; +import java.beans.PropertyChangeListener; +import java.io.Closeable; + +import static org.nuiton.i18n.I18n.t; + +/** + * To manage the average weights histogram. + * + * Created on 14/04/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class AverageWeightsHistogramHandler implements Closeable { + + /** Logger. */ + private static final Log log = LogFactory.getLog(AverageWeightsHistogramHandler.class); + + private final AverageWeightsHistogramModel model; + + private final JFreeChart chart; + private final JFrame popup; + + public AverageWeightsHistogramHandler(SpeciesFrequencyUI ui) { + + SpeciesFrequencyUIHandler uiHandler = ui.getHandler(); + SpeciesFrequencyUIModel uiModel = ui.getModel(); + + model = uiModel.getAverageWeightsHistogramModel(); + + chart = ChartFactory.createXYLineChart(null, + t("tutti.editSpeciesFrequencies.table.header.lengthStep"), + model.getIndividualObservationWeightUnit().decorateLabel(t("tutti.editSpeciesFrequencies.averageWeight.label")), + model.getDataset()); + chart.clearSubtitles(); + + ValueAxis rangeAxis = chart.getXYPlot().getRangeAxis(); + rangeAxis.setAutoRange(true); + rangeAxis.setStandardTickUnits(new NumberTickUnitSource()); + rangeAxis.setMinorTickMarksVisible(true); + + ValueAxis domainAxis = chart.getXYPlot().getDomainAxis(); + domainAxis.setAutoRange(true); + domainAxis.setStandardTickUnits(new TuttiNumberTickUnitSource(true)); + domainAxis.setMinorTickMarksVisible(true); + + XYLineAndShapeRenderer plotRenderer = (XYLineAndShapeRenderer) chart.getXYPlot().getRenderer(); + plotRenderer.setSeriesPaint(0, uiHandler.getConfig().getColorComputedWeights()); + plotRenderer.setBaseShapesVisible(true); + + ChartPanel chartPanel = new ChartPanel(chart); + chartPanel.setDomainZoomable(false); + chartPanel.setMouseZoomable(false); + chartPanel.setPopupMenu(null); + + popup = new JFrame(); + popup.getContentPane().add(chartPanel); + popup.pack(); + + // when step has changed in model, update chart + uiModel.addPropertyChangeListener(SpeciesFrequencyUIModel.PROPERTY_STEP, new PropertyChangeListener() { + @Override + public void propertyChange(PropertyChangeEvent evt) { + + Float step1 = (Float) evt.getNewValue(); + model.setStep(step1); + + } + }); + + // when lengthStepCaracteristicUnit changed, let's updates the label of some fields + uiModel.addPropertyChangeListener(SpeciesFrequencyUIModel.PROPERTY_LENGTH_STEP_CARACTERISTIC_UNIT, new PropertyChangeListener() { + @Override + public void propertyChange(PropertyChangeEvent evt) { + + String unit = (String) evt.getNewValue(); + + if (unit == null) { + + unit = t("tutti.editSpeciesFrequencies.unkownStepUnit"); + } + + String lengthStepLabelWithUnit = Units.getLabelWithUnit(t("tutti.editSpeciesFrequencies.table.header.lengthStep"), unit); + model.setLengthStepLabelWithUnit(lengthStepLabelWithUnit); + + } + }); + + model.addPropertyChangeListener(AverageWeightsHistogramModel.PROPERTY_TITLE, new PropertyChangeListener() { + @Override + public void propertyChange(PropertyChangeEvent evt) { + String title = (String) evt.getNewValue(); + if (log.isInfoEnabled()) { + log.info("Average weights graph title changed to: " + title); + } + popup.setTitle(title); + } + }); + + model.addPropertyChangeListener(AverageWeightsHistogramModel.PROPERTY_LENGTH_STEP_LABEL_WITH_UNIT, new PropertyChangeListener() { + @Override + public void propertyChange(PropertyChangeEvent evt) { + String lengthStepLabelWithUnit = (String) evt.getNewValue(); + if (log.isInfoEnabled()) { + log.info("Average weights graph lengthStepLabelWithUnit changed to: " + lengthStepLabelWithUnit); + } + chart.getXYPlot().getDomainAxis().setLabel(lengthStepLabelWithUnit); + } + }); + + model.addPropertyChangeListener(AverageWeightsHistogramModel.PROPERTY_STEP, new PropertyChangeListener() { + @Override + public void propertyChange(PropertyChangeEvent evt) { + + Float step = (Float) evt.getNewValue(); + if (log.isInfoEnabled()) { + log.info("Average weights graph step changed to: " + step); + } + chart.getXYPlot().getDomainAxis().setStandardTickUnits(new TuttiNumberTickUnitSource(step == 1f)); + model.getDataset().setIntervalWidth(step); + + } + }); + + // Show graphic in popup when fires button action + ui.getGraphAverageWeightButton().addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent e) { + popup.setVisible(true); + } + }); + + } + + @Override + public void close() { + popup.dispose(); + } + +} diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/AverageWeightsHistogramModel.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/AverageWeightsHistogramModel.java new file mode 100644 index 0000000..fdf1375 --- /dev/null +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/AverageWeightsHistogramModel.java @@ -0,0 +1,120 @@ +package fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency; + +import fr.ifremer.tutti.type.WeightUnit; +import fr.ifremer.tutti.util.Weights; +import org.jdesktop.beans.AbstractSerializableBean; +import org.jfree.data.xy.XYSeries; +import org.jfree.data.xy.XYSeriesCollection; + +import java.util.List; + +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 15/04/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class AverageWeightsHistogramModel extends AbstractSerializableBean { + + public static final String PROPERTY_TITLE = "title"; + public static final String PROPERTY_LENGTH_STEP_LABEL_WITH_UNIT = "lengthStepLabelWithUnit"; + public static final String PROPERTY_STEP = "step"; + + /** + * To store average weights graph series. + * + * @since 4.5 + */ + private final XYSeriesCollection dataset; + protected final XYSeries series; + + private final WeightUnit frequencyWeightUnit; + private final WeightUnit individualObservationWeightUnit; + + private String title; + private String lengthStepLabelWithUnit; + private Float step; + + public AverageWeightsHistogramModel(WeightUnit frequencyWeightUnit, WeightUnit individualObservationWeightUnit) { + this.frequencyWeightUnit = frequencyWeightUnit; + this.individualObservationWeightUnit = individualObservationWeightUnit; + + series = new XYSeries("", true, false); + dataset = new XYSeriesCollection(series); + dataset.setIntervalPositionFactor(0); + dataset.setIntervalWidth(0); + + } + + public WeightUnit getIndividualObservationWeightUnit() { + return individualObservationWeightUnit; + } + + public XYSeriesCollection getDataset() { + return dataset; + } + + public String getTitle() { + return title; + } + + public void setTitle(String title) { + + title = title + frequencyWeightUnit.decorateLabel(t("tutti.editSpeciesFrequencies.field.graphAverageWeight")); + + Object oldValue = getTitle(); + this.title = title; + firePropertyChange(PROPERTY_TITLE, oldValue, title); + } + + public String getLengthStepLabelWithUnit() { + return lengthStepLabelWithUnit; + } + + public void setLengthStepLabelWithUnit(String lengthStepLabelWithUnit) { + Object oldValue = getLengthStepLabelWithUnit(); + this.lengthStepLabelWithUnit = lengthStepLabelWithUnit; + firePropertyChange(PROPERTY_LENGTH_STEP_LABEL_WITH_UNIT, oldValue, lengthStepLabelWithUnit); + } + + public Float getStep() { + return step; + } + + public void setStep(Float step) { + Object oldValue = getStep(); + this.step = step; + firePropertyChange(PROPERTY_STEP, oldValue, step); + } + + public void reloadRows(List<SpeciesFrequencyRowModel> rows) { + + series.clear(); + + if (rows != null) { + + rows.stream().filter(SpeciesFrequencyRowModel::isValid).forEach(this::addOrUpdate); + + } + + } + + public void addOrUpdate(SpeciesFrequencyRowModel row) { + + Float weight = Weights.convert(frequencyWeightUnit, individualObservationWeightUnit, row.computeAverageWeight()); + series.addOrUpdate(row.getLengthStep(), weight); + + } + + public void removeValue(Float lengthStep) { + if (series.indexOf(lengthStep) >= 0) { + if (series.getItemCount() > 1) { + series.remove(lengthStep); + } else { + series.clear(); + } + } + } + +} diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/FrequenciesHistogramHandler.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/FrequenciesHistogramHandler.java new file mode 100644 index 0000000..e741e44 --- /dev/null +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/FrequenciesHistogramHandler.java @@ -0,0 +1,166 @@ +package fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency; + +import fr.ifremer.tutti.ui.swing.util.TuttiNumberTickUnitSource; +import fr.ifremer.tutti.util.Units; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.jfree.chart.ChartFactory; +import org.jfree.chart.ChartPanel; +import org.jfree.chart.JFreeChart; +import org.jfree.chart.axis.NumberTickUnitSource; +import org.jfree.chart.axis.ValueAxis; + +import javax.swing.JFrame; +import java.awt.BorderLayout; +import java.awt.event.MouseAdapter; +import java.awt.event.MouseEvent; +import java.beans.PropertyChangeEvent; +import java.beans.PropertyChangeListener; +import java.io.Closeable; + +import static org.nuiton.i18n.I18n.t; + +/** + * To manage the frequencies histogram. + * + * Created on 14/04/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class FrequenciesHistogramHandler implements Closeable { + + /** Logger. */ + private static final Log log = LogFactory.getLog(FrequenciesHistogramHandler.class); + + private final FrequenciesHistogramModel model; + + private final JFreeChart chart; + private final JFrame popup; + + public FrequenciesHistogramHandler(SpeciesFrequencyUI ui) { + + SpeciesFrequencyUIModel uiModel = ui.getModel(); + SpeciesFrequencyUIHandler uiHandler = ui.getHandler(); + +// this.frequencyTableModel = uiHandler.getTableModel(); + + this.model = uiModel.getFrequenciesHistogramModel(); + + chart = ChartFactory.createXYBarChart(null, + t("tutti.editSpeciesFrequencies.table.header.lengthStep"), + false, + t("tutti.editSpeciesFrequencies.table.header.number"), + model.getDataset()); + chart.clearSubtitles(); + + ValueAxis rangeAxis = chart.getXYPlot().getRangeAxis(); + rangeAxis.setAutoRange(true); + rangeAxis.setStandardTickUnits(new NumberTickUnitSource(true)); + + ValueAxis domainAxis = chart.getXYPlot().getDomainAxis(); + domainAxis.setAutoRange(true); + domainAxis.setStandardTickUnits(new TuttiNumberTickUnitSource(true)); + domainAxis.setMinorTickMarksVisible(true); + + chart.getXYPlot().getRenderer().setSeriesPaint(0, uiHandler.getConfig().getColorComputedWeights()); + + ChartPanel chartPanel = new ChartPanel(chart); + chartPanel.setDomainZoomable(false); + chartPanel.setMouseZoomable(false); + chartPanel.setPopupMenu(null); + + ui.getHistogramPanel().add(chartPanel, BorderLayout.CENTER); + + popup = new JFrame(); + chartPanel.addMouseListener(new MouseAdapter() { + + @Override + public void mouseClicked(MouseEvent e) { + super.mouseClicked(e); + if (e.getClickCount() > 1) { + + popup.getContentPane().removeAll(); + ChartPanel chartPanel = new ChartPanel(chart); + popup.getContentPane().add(chartPanel); + popup.pack(); + popup.setVisible(true); + + } + } + }); + + // when step has changed in model, update chart + uiModel.addPropertyChangeListener(SpeciesFrequencyUIModel.PROPERTY_STEP, new PropertyChangeListener() { + @Override + public void propertyChange(PropertyChangeEvent evt) { + + Float step1 = (Float) evt.getNewValue(); + model.setStep(step1); + + } + }); + + // when lengthStepCaracteristicUnit changed, let's updates the label of some fields + uiModel.addPropertyChangeListener(SpeciesFrequencyUIModel.PROPERTY_LENGTH_STEP_CARACTERISTIC_UNIT, new PropertyChangeListener() { + @Override + public void propertyChange(PropertyChangeEvent evt) { + + String unit = (String) evt.getNewValue(); + + if (unit == null) { + + unit = t("tutti.editSpeciesFrequencies.unkownStepUnit"); + } + + String lengthStepLabelWithUnit = Units.getLabelWithUnit(t("tutti.editSpeciesFrequencies.table.header.lengthStep"), unit); + model.setLengthStepLabelWithUnit(lengthStepLabelWithUnit); + + } + + }); + + model.addPropertyChangeListener(AverageWeightsHistogramModel.PROPERTY_TITLE, new PropertyChangeListener() { + @Override + public void propertyChange(PropertyChangeEvent evt) { + String title = (String) evt.getNewValue(); + if (log.isInfoEnabled()) { + log.info("Frequencies graph title changed to: " + title); + } + popup.setTitle(title); + } + }); + + model.addPropertyChangeListener(AverageWeightsHistogramModel.PROPERTY_LENGTH_STEP_LABEL_WITH_UNIT, new PropertyChangeListener() { + @Override + public void propertyChange(PropertyChangeEvent evt) { + String lengthStepLabelWithUnit = (String) evt.getNewValue(); + if (log.isInfoEnabled()) { + log.info("Frequencies graph lengthStepLabelWithUnit changed to: " + lengthStepLabelWithUnit); + } + chart.getXYPlot().getDomainAxis().setLabel(lengthStepLabelWithUnit); + } + }); + + model.addPropertyChangeListener(AverageWeightsHistogramModel.PROPERTY_STEP, new PropertyChangeListener() { + @Override + public void propertyChange(PropertyChangeEvent evt) { + + Float step = (Float) evt.getNewValue(); + if (log.isInfoEnabled()) { + log.info("Frequencies graph step changed to: " + step); + } + + chart.getXYPlot().getDomainAxis().setStandardTickUnits(new TuttiNumberTickUnitSource(step == 1f)); + model.getDataset().setIntervalWidth(step); + + } + }); + + } + + @Override + public void close() { + popup.dispose(); + } + +} diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/FrequenciesHistogramModel.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/FrequenciesHistogramModel.java new file mode 100644 index 0000000..0171a41 --- /dev/null +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/FrequenciesHistogramModel.java @@ -0,0 +1,113 @@ +package fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency; + +import fr.ifremer.tutti.type.WeightUnit; +import org.jdesktop.beans.AbstractSerializableBean; +import org.jfree.data.xy.XYSeries; +import org.jfree.data.xy.XYSeriesCollection; + +import java.util.List; + +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 15/04/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class FrequenciesHistogramModel extends AbstractSerializableBean { + + public static final String PROPERTY_TITLE = "title"; + public static final String PROPERTY_LENGTH_STEP_LABEL_WITH_UNIT = "lengthStepLabelWithUnit"; + public static final String PROPERTY_STEP = "step"; + + /** + * To store frequencies graph series. + * + * @since 3.11 + */ + private final XYSeriesCollection dataset; + protected final XYSeries series; + + private final WeightUnit frequencyWeightUnit; + private final WeightUnit individualObservationWeightUnit; + + private String title; + private String lengthStepLabelWithUnit; + private Float step; + + public FrequenciesHistogramModel(WeightUnit frequencyWeightUnit, WeightUnit individualObservationWeightUnit) { + this.frequencyWeightUnit = frequencyWeightUnit; + this.individualObservationWeightUnit = individualObservationWeightUnit; + + series = new XYSeries("", true, false); + + dataset = new XYSeriesCollection(series); + dataset.setIntervalPositionFactor(0); + dataset.setIntervalWidth(0); + + } + + public XYSeriesCollection getDataset() { + return dataset; + } + + public String getTitle() { + return title; + } + + public void setTitle(String title) { + + title = title + t("tutti.editSpeciesFrequencies.title"); + + Object oldValue = getTitle(); + this.title = title; + firePropertyChange(PROPERTY_TITLE, oldValue, title); + } + + public String getLengthStepLabelWithUnit() { + return lengthStepLabelWithUnit; + } + + public void setLengthStepLabelWithUnit(String lengthStepLabelWithUnit) { + Object oldValue = getLengthStepLabelWithUnit(); + this.lengthStepLabelWithUnit = lengthStepLabelWithUnit; + firePropertyChange(PROPERTY_LENGTH_STEP_LABEL_WITH_UNIT, oldValue, lengthStepLabelWithUnit); + } + + public Float getStep() { + return step; + } + + public void setStep(Float step) { + Object oldValue = getStep(); + this.step = step; + firePropertyChange(PROPERTY_STEP, oldValue, step); + } + + public void reloadRows(List<SpeciesFrequencyRowModel> rows) { + + series.clear(); + + if (rows != null) { + + rows.stream().filter(SpeciesFrequencyRowModel::isValid).forEach(this::addOrUpdate); + + } + + } + + public void addOrUpdate(SpeciesFrequencyRowModel row) { + series.addOrUpdate(row.getLengthStep(), row.getNumber()); + } + + public void removeValue(Float lengthStep) { + if (series.indexOf(lengthStep) >= 0) { + if (series.getItemCount() > 1) { + series.remove(lengthStep); + } else { + series.clear(); + } + } + } + +} diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/individualobservation/IndividualObservationBatchRowModel.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/IndividualObservationBatchRowModel.java similarity index 99% rename from tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/individualobservation/IndividualObservationBatchRowModel.java rename to tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/IndividualObservationBatchRowModel.java index a9ad8d0..c22191b 100644 --- a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/individualobservation/IndividualObservationBatchRowModel.java +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/IndividualObservationBatchRowModel.java @@ -1,4 +1,4 @@ -package fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation; +package fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency; /* * #%L diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/IndividualObservationBatchTableHandler.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/IndividualObservationBatchTableHandler.java new file mode 100644 index 0000000..8fd6d3b --- /dev/null +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/IndividualObservationBatchTableHandler.java @@ -0,0 +1,665 @@ +package fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency; + +import com.google.common.collect.Sets; +import fr.ifremer.tutti.persistence.entities.CaracteristicMap; +import fr.ifremer.tutti.persistence.entities.TuttiEntities; +import fr.ifremer.tutti.persistence.entities.data.Attachment; +import fr.ifremer.tutti.persistence.entities.data.CopyIndividualObservationMode; +import fr.ifremer.tutti.persistence.entities.data.FishingOperation; +import fr.ifremer.tutti.persistence.entities.data.SampleCategory; +import fr.ifremer.tutti.persistence.entities.protocol.SpeciesProtocol; +import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; +import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValue; +import fr.ifremer.tutti.persistence.entities.referential.Species; +import fr.ifremer.tutti.service.DecoratorService; +import fr.ifremer.tutti.service.sampling.SamplingCodePrefix; +import fr.ifremer.tutti.type.WeightUnit; +import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.SamplingCodeCellEditor; +import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.SamplingCodeCellRenderer; +import fr.ifremer.tutti.ui.swing.content.operation.catches.species.edit.SpeciesBatchRowModel; +import fr.ifremer.tutti.ui.swing.util.TuttiUI; +import fr.ifremer.tutti.ui.swing.util.TuttiUIUtil; +import fr.ifremer.tutti.ui.swing.util.attachment.AttachmentCellEditor; +import fr.ifremer.tutti.ui.swing.util.attachment.AttachmentCellRenderer; +import fr.ifremer.tutti.ui.swing.util.caracteristics.CaracteristicMapCellComponent; +import fr.ifremer.tutti.ui.swing.util.comment.CommentCellEditor; +import fr.ifremer.tutti.ui.swing.util.comment.CommentCellRenderer; +import jaxx.runtime.SwingUtil; +import org.apache.commons.lang3.StringUtils; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.jdesktop.swingx.JXTable; +import org.jdesktop.swingx.decorator.HighlightPredicate; +import org.jdesktop.swingx.decorator.Highlighter; +import org.jdesktop.swingx.table.DefaultTableColumnModelExt; +import org.jdesktop.swingx.table.TableColumnExt; +import org.jdesktop.swingx.table.TableColumnModelExt; +import org.nuiton.jaxx.application.swing.table.ColumnIdentifier; + +import javax.swing.JOptionPane; +import javax.swing.event.TableModelEvent; +import java.awt.Color; +import java.beans.PropertyChangeListener; +import java.beans.PropertyVetoException; +import java.io.Closeable; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Set; + +import static org.nuiton.i18n.I18n.t; +import static org.nuiton.jaxx.application.swing.AbstractApplicationUIHandler.CONFIRMATION_FORMAT; + +/** + * To manage individual observations. + * + * Created on 14/04/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class IndividualObservationBatchTableHandler implements Closeable { + + /** Logger. */ + private static final Log log = LogFactory.getLog(IndividualObservationBatchTableHandler.class); + + private final SpeciesFrequencyUI ui; + private final SpeciesFrequencyUIHandler uiHandler; + private final JXTable individualObservationTable; + + private final SpeciesFrequencyUIModel model; + private final SpeciesFrequencyTableModel frequencyTableModel; + private final IndividualObservationBatchTableModel individualObservationTableModel; + + private final IndividualObservationUICache individualObservationUICache; + private final Map<String, Caracteristic> maturityCaracteristics; + + private ColumnIdentifier<IndividualObservationBatchRowModel> maturityColumnId; + + /** + * Added on each individual observation row in the dedicated table. + * Notify each time a modification is done on a such row. + */ + private final PropertyChangeListener individualObservationRowChangedListener; + + public IndividualObservationBatchTableHandler(SpeciesFrequencyUI ui) { + + this.ui = ui; + this.model = ui.getModel(); + this.uiHandler = ui.getHandler(); + this.individualObservationUICache = new IndividualObservationUICache(uiHandler.getDataContext().getOptionalCruiseSamplingCache().orElse(null), model); + this.individualObservationTable = ui.getObsTable(); + this.frequencyTableModel = uiHandler.getTableModel(); + + List<Caracteristic> maturityCaracteristics = new ArrayList<>(uiHandler.getDataContext().getMaturityCaracteristics()); + + this.maturityCaracteristics = TuttiEntities.splitById(maturityCaracteristics); + + // When any change on any individual observation + this.individualObservationRowChangedListener = evt -> { + + IndividualObservationBatchRowModel row = (IndividualObservationBatchRowModel) evt.getSource(); + String propertyName = evt.getPropertyName(); + + CaracteristicQualitativeValue gender = model.getGender(row); + CaracteristicQualitativeValue maturity = model.getMaturityValue(row); + + switch (propertyName) { + case IndividualObservationBatchRowModel.PROPERTY_SIZE: { + + Float oldValue = (Float) evt.getOldValue(); + Float newValue = (Float) evt.getNewValue(); + + if (oldValue != null) { + individualObservationUICache.decrementsObservationNb(gender, maturity, oldValue, row.getSamplingCode()); + } + if (newValue != null) { + individualObservationUICache.incrementsObservationNb(gender, maturity, newValue, row.getSamplingCode()); + } + + // we only update the frequencies if the row is valid + if (row.isValid() && model.mustCopyIndividualObservationSize()) { + + if (oldValue != null) { + frequencyTableModel.decrementFrequencyRowsNumbers(oldValue); + } + if (newValue != null) { + frequencyTableModel.incrementFrequencyRowsNumbers(newValue); + } + + if (model.isCopyIndividualObservationAll() && row.withWeight()) { + float weight = row.getWeight(); + if (oldValue != null) { + frequencyTableModel.removeWeightToFrequencyRow(oldValue, weight); + } + if (newValue != null) { + frequencyTableModel.addWeightToFrequencyRow(newValue, weight); + } + } + } + } + break; + + case IndividualObservationBatchRowModel.PROPERTY_WEIGHT: + if (row.isValid() && model.isCopyIndividualObservationAll()) { + + Float oldValue = (Float) evt.getOldValue(); + Float newValue = (Float) evt.getNewValue(); + Float weightToAdd; + + if (oldValue == null) { + weightToAdd = newValue; + + } else if (newValue == null) { + weightToAdd = -oldValue; + + } else { + weightToAdd = newValue - oldValue; + } + + WeightUnit weightUnit = model.getWeightUnit(); + + if (weightUnit.isNotNullNorZero(weightToAdd)) { + if (weightUnit.isGreaterThanZero(weightToAdd)) { + frequencyTableModel.addWeightToFrequencyRow(row, weightToAdd); + } else { + frequencyTableModel.removeWeightToFrequencyRow(row, -weightToAdd); + } + } + } + break; + + case IndividualObservationBatchRowModel.PROPERTY_DEFAULT_CARACTERISTICS: + case IndividualObservationBatchRowModel.PROPERTY_CARACTERISTICS: + if (row.withSize()) { + CaracteristicMap oldValue = (CaracteristicMap) evt.getOldValue(); + CaracteristicMap newValue = (CaracteristicMap) evt.getNewValue(); + + if (log.isInfoEnabled()) { + log.info("caracteristics changed"); + } + + if (model.withMaturityCaracteristic()) { + CaracteristicQualitativeValue oldMaturity = model.getMaturityValue(oldValue); + CaracteristicQualitativeValue newMaturity = model.getMaturityValue(newValue); + if (log.isInfoEnabled()) { + log.info("maturities : " + oldMaturity + " " + newMaturity); + } + if (!Objects.equals(oldMaturity, newMaturity)) { + individualObservationUICache.decrementsObservationNb(gender, oldMaturity, row.getSize()); + individualObservationUICache.incrementsObservationNb(gender, newMaturity, row.getSize(), row.getSamplingCode()); + } + } + + CaracteristicQualitativeValue oldGender = model.getGender(oldValue); + CaracteristicQualitativeValue newGender = model.getGender(newValue); + if (!Objects.equals(oldGender, newGender)) { + individualObservationUICache.decrementsObservationNb(oldGender, maturity, row.getSize()); + individualObservationUICache.incrementsObservationNb(newGender, maturity, row.getSize(), row.getSamplingCode()); + } + } + break; + + case IndividualObservationBatchRowModel.PROPERTY_SAMPLING_CODE: + if (row.withSize()) { + + float size = row.getSize(); + + String oldValue = (String) evt.getOldValue(); + String newValue = (String) evt.getNewValue(); + + if (StringUtils.isNotBlank(oldValue)) { + individualObservationUICache.decrementsSamplingNb(gender, maturity, size, oldValue); + } + if (StringUtils.isNotBlank(newValue)) { + individualObservationUICache.incrementsSamplingNb(gender, maturity, size, newValue); + } + } + break; + + case IndividualObservationBatchRowModel.PROPERTY_VALID: + // if the row's valid state changes, then remove or readd it to the frequencies + if (!model.isRowComputationInProgress()) { + boolean oldValue = (boolean) evt.getOldValue(); + boolean newValue = (boolean) evt.getNewValue(); + + if (oldValue && model.mustCopyIndividualObservationSize()) { + + frequencyTableModel.decrementFrequencyRowsNumbers(row); + } + if (newValue) { + if (model.mustCopyIndividualObservationSize()) { + frequencyTableModel.incrementFrequencyRowsNumbers(row); + } + if (model.isCopyIndividualObservationAll() && row.withWeight()) { + frequencyTableModel.addWeightToFrequencyRow(row, row.getWeight()); + } + } + } + break; + } + + model.recomputeIndividualObservationRowValidState(row); + model.recomputeCanEditLengthStep(); + + model.setModify(true); + + }; + + // can show / hide some columns in model + individualObservationTable.setColumnControlVisible(true); + + // create obsTable column model + DefaultTableColumnModelExt columnModel = new DefaultTableColumnModelExt(); + + { + // Rank column + + uiHandler.addIntegerColumnToModel(columnModel, + IndividualObservationBatchTableModel.RANK, + TuttiUI.INT_10_DIGITS_PATTERN, + individualObservationTable); + + } + + { // Size column + + uiHandler.addFloatColumnToModel(columnModel, + IndividualObservationBatchTableModel.SIZE, + TuttiUI.DECIMAL3_PATTERN, + individualObservationTable); + } + + WeightUnit individualObservationWeightUnit = uiHandler.getConfig().getIndividualObservationWeightUnit(); + + { // Weight column + + uiHandler.addFloatColumnToModel(columnModel, + IndividualObservationBatchTableModel.WEIGHT, + individualObservationWeightUnit, + individualObservationTable); + } + + List<Caracteristic> defaultCaracteristic = model.getDefaultCaracteristic(); + + for (Caracteristic caracteristic : defaultCaracteristic) { + uiHandler.addCaracteristicColumnToModel(individualObservationTable, + columnModel, + caracteristic); + } + + { // Other caracteristics column + + Set<Caracteristic> caracteristicsToSkip = Collections.unmodifiableSet( + Sets.newHashSet(model.getDefaultCaracteristic())); + + uiHandler.addColumnToModel(columnModel, + CaracteristicMapCellComponent.newEditor(ui, caracteristicsToSkip), + CaracteristicMapCellComponent.newRender(uiHandler.getContext()), + IndividualObservationBatchTableModel.OTHER_CARACTERISTICS); + + } + + { + // Smapling code column + + uiHandler.addColumnToModel(columnModel, + SamplingCodeCellEditor.newEditor(ui), + SamplingCodeCellRenderer.newRender(), + IndividualObservationBatchTableModel.SAMPLING_CODE); + + } + + { // Comment column + + uiHandler.addColumnToModel(columnModel, + CommentCellEditor.newEditor(ui), + CommentCellRenderer.newRender(), + IndividualObservationBatchTableModel.COMMENT); + + } + + { // File column + + uiHandler.addColumnToModel(columnModel, + AttachmentCellEditor.newEditor(ui), + AttachmentCellRenderer.newRender(uiHandler.getDecorator(Attachment.class, null)), + IndividualObservationBatchTableModel.ATTACHMENT); + } + + // create obsTable model + individualObservationTableModel = new IndividualObservationBatchTableModel(individualObservationWeightUnit, model, columnModel); + + individualObservationTable.setModel(individualObservationTableModel); + individualObservationTable.setColumnModel(columnModel); + + // by default do not authorize to change column orders + individualObservationTable.getTableHeader().setReorderingAllowed(false); + + uiHandler.addHighlighters(individualObservationTable); + + Color cellWithValueColor = uiHandler.getConfig().getColorCellWithValue(); + + Highlighter commentHighlighter = TuttiUIUtil.newBackgroundColorHighlighter( + new HighlightPredicate.AndHighlightPredicate( + new HighlightPredicate.IdentifierHighlightPredicate(IndividualObservationBatchTableModel.COMMENT), + // for not null value + (renderer, adapter) -> { + String value = (String) adapter.getValue(); + return StringUtils.isNotBlank(value); + }), cellWithValueColor); + individualObservationTable.addHighlighter(commentHighlighter); + + uiHandler.installTableKeyListener(columnModel, individualObservationTable, false); + + // always scroll to selected row + SwingUtil.scrollToTableSelection(individualObservationTable); + + this.individualObservationTableModel.addTableModelListener(e -> { + + int firstRow = e.getFirstRow(); + int lastRow = e.getLastRow(); + + switch (e.getType()) { + case TableModelEvent.DELETE: + if (this.individualObservationTableModel.getRowCount() == 0) { + this.individualObservationTableModel.addNewRow(); + + } else { + this.individualObservationTableModel.recomputeRankOrders(firstRow); + } + break; + + case TableModelEvent.INSERT: + for (int i = firstRow; i <= lastRow; i++) { + IndividualObservationBatchRowModel newRow = this.individualObservationTableModel.getRows().get(i); + newRow.addPropertyChangeListener(individualObservationRowChangedListener); + + if (model.mustCopyIndividualObservationSize()) { + + frequencyTableModel.incrementFrequencyRowsNumbers(newRow); + + } + + model.recomputeIndividualObservationRowValidState(newRow); + } + break; + + case TableModelEvent.UPDATE: + if (this.individualObservationTableModel.getRowCount() == 0) { + this.individualObservationTableModel.addNewRow(); + } + } + + model.recomputeCanEditLengthStep(); + }); + + this.individualObservationTable.getSelectionModel().addListSelectionListener(e -> { + + if (!model.isInRafaleRowCreation()) { + uiHandler.resetSamplingLabel(); + } + + IndividualObservationBatchRowModel selectedRow = null; + + if (!this.individualObservationTable.getSelectionModel().isSelectionEmpty()) { + if (this.individualObservationTable.getSelectedRowCount() == 1) { + selectedRow = this.individualObservationTableModel.getEntry(this.individualObservationTable.getSelectedRow()); + + } + } + + individualObservationUICache.updateSelectedRow(selectedRow); + }); + + model.addPropertyChangeListener(SpeciesFrequencyUIModel.PROPERTY_INDIVIDUAL_OBSERVATION_ROWS, evt -> { + individualObservationTableModel.setRows((List<IndividualObservationBatchRowModel>) evt.getNewValue()); + }); + + // Pour bloquer le changement du mode de recopie des observations individuelles → mensurations + model.addVetoableChangeListener(SpeciesFrequencyUIModel.PROPERTY_COPY_INDIVIDUAL_OBSERVATION_MODE, evt -> { + + SpeciesFrequencyUIModel source = (SpeciesFrequencyUIModel) evt.getSource(); + CopyIndividualObservationMode oldCopyMode = (CopyIndividualObservationMode) evt.getOldValue(); + CopyIndividualObservationMode newCopyMode = (CopyIndividualObservationMode) evt.getNewValue(); + + if (source.isInitBatchEdition()) { + + if (log.isInfoEnabled()) { + log.info("Skip ask user to confirm copyIndividualObservationMode changed from " + oldCopyMode + " to " + newCopyMode); + } + return; + } + + // le seul mode où l'utilisateur ne peut rien saisir est le mode tout + if (CopyIndividualObservationMode.ALL != oldCopyMode) { + + long rowsWithUserData; + + // si on etait en mode taille et que l'utilisateur avait saisi des tailles + if (oldCopyMode == CopyIndividualObservationMode.SIZE) { + rowsWithUserData = model.getRows().stream() + .filter(SpeciesFrequencyRowModel::withWeight) + .count(); + + } else { + rowsWithUserData = model.getRows().stream() + .filter(row -> row.getLengthStep() != null || row.withNumber() || row.withWeight()) + .count(); + } + + if (rowsWithUserData > 0) { + + String htmlMessage = String.format( + CONFIRMATION_FORMAT, + t("tutti.editSpeciesFrequencies.changeCopyMode.confirm.message"), + t("tutti.editSpeciesFrequencies.changeCopyMode.confirm.help")); + int i = JOptionPane.showConfirmDialog( + uiHandler.getTopestUI(), + htmlMessage, + t("tutti.editSpeciesFrequencies.changeCopyMode.confirm.title"), + JOptionPane.OK_CANCEL_OPTION, + JOptionPane.QUESTION_MESSAGE); + + if (i == JOptionPane.CANCEL_OPTION) { + throw new PropertyVetoException("The user does not want to erase his data.", evt); + } + } + } + }); + + // Pour mettre à jour les mensurations suite au changement du mode de recopie des observations individuelles + model.addPropertyChangeListener(SpeciesFrequencyUIModel.PROPERTY_COPY_INDIVIDUAL_OBSERVATION_MODE, evt -> { + + SpeciesFrequencyUIModel source = (SpeciesFrequencyUIModel) evt.getSource(); + CopyIndividualObservationMode oldCopyMode = (CopyIndividualObservationMode) evt.getOldValue(); + CopyIndividualObservationMode newCopyMode = (CopyIndividualObservationMode) evt.getNewValue(); + + if (newCopyMode == null) { + + return; + } + boolean nothingCopyMode = CopyIndividualObservationMode.NOTHING == newCopyMode; + + + if (!nothingCopyMode) { + + source.setFrequenciesConfigurationMode(FrequencyConfigurationMode.RAFALE); + source.setAddIndividualObservationOnRafale(true); + + } + + + // si on est en initialisation, ca ne sert à rien de regénérer les lignes, elles sont sensées être chargées + if (source.isInitBatchEdition()) { + + if (log.isInfoEnabled()) { + log.info("Skip recompute frequencies from indivudal observations (flag initBatchEdition is on), copyIndividualObservationMode changed from " + oldCopyMode + " to " + newCopyMode); + } + return; + } + + model.setRowComputationInProgress(true); + + try { + + model.getRows().clear(); + model.getRowsInError().clear(); + model.reloadRows(); + model.recomputeIndividualObservationRowsValidateState(); + uiHandler.reloadRowsFromIndividualObservations(); + + } finally { + model.setRowComputationInProgress(false); + } + + frequencyTableModel.fireTableDataChanged(); + individualObservationTableModel.fireTableDataChanged(); + + }); + + model.addPropertyChangeListener(SpeciesFrequencyUIModel.PROPERTY_LENGTH_STEP_CARACTERISTIC, evt -> { + + Caracteristic newValue = (Caracteristic) evt.getNewValue(); + individualObservationTableModel.setLengthstepCaracteristic(newValue); + + }); + + } + + @Override + public void close() { + + uiHandler.resetSamplingLabel(); + + // on supprime la colonne maturité en fermant, pour avoir les même colonnes qu'à la création de l'écran (important pour la swing session) + removeMaturityColumnIfPresent(); + + individualObservationUICache.close(); + + } + + protected void removeMaturityColumnIfPresent() { + if (maturityColumnId != null) { + TableColumnExt maturityColumn = individualObservationTable.getColumnExt(maturityColumnId); + individualObservationTable.removeColumn(maturityColumn); + individualObservationTableModel.removeMaturityIdentifier(maturityColumnId); + maturityColumnId = null; + } + } + + public List<IndividualObservationBatchRowModel> loadIndividualObservations(Species species, List<IndividualObservationBatchRowModel> individualObservations) { + + individualObservationTableModel.setSpecies(species); + + SamplingCodePrefix samplingCodePrefix = new SamplingCodePrefix(uiHandler.getConfig().getSamplingCodePrefix(), uiHandler.decorate(species, DecoratorService.WITH_SURVEY_CODE_NO_NAME)); + individualObservationTableModel.setSamplingCodePrefix(samplingCodePrefix); + + return individualObservationTableModel.loadRows(individualObservations, individualObservationRowChangedListener); + + } + + public void setMaturityCaracteristic(Caracteristic maturityCaracteristic) { + model.setMaturityCaracteristic(maturityCaracteristic); + if (maturityCaracteristic != null) { + addMaturityCaracteristicColumnToModel(maturityCaracteristic); + } + } + + public void addMaturityCaracteristicColumnToModel(Caracteristic caracteristic) { + + // remove the row sorter while we add the new column + individualObservationTable.setRowSorter(null); + individualObservationTable.setAutoCreateRowSorter(false); + + TableColumnModelExt columnModel = (TableColumnModelExt) individualObservationTable.getColumnModel(); + + ColumnIdentifier<IndividualObservationBatchRowModel> maturityColumnId = uiHandler.addCaracteristicColumnToModel(individualObservationTable, + columnModel, + caracteristic); + + Objects.requireNonNull(maturityColumnId); + this.maturityColumnId = maturityColumnId; + + individualObservationTableModel.addMaturityIdentifier(maturityColumnId); + + // on cherche le bon index où insérer la colonne maturité (avant les autres caractéristiques, mais elle peut etre cachee) + int modelIndex = columnModel.getColumnExt(IndividualObservationBatchTableModel.OTHER_CARACTERISTICS).getModelIndex(); + int indexToMove = individualObservationTable.convertColumnIndexToView(modelIndex); + + // si la colonne autres caracteristiques est cachée, alors on cherche la première colonne suivante non cachée + int columnCount = columnModel.getColumnCount(true); + while (indexToMove == -1 && modelIndex < columnCount) { + indexToMove = individualObservationTable.convertColumnIndexToView(modelIndex); + modelIndex++; + } + // si une colonne après celle des autres caractéristiques est visible, on déplace la maturité avant cette colonne + // sinon, on laisse la maturité à la fin + if (modelIndex != -1) { + individualObservationTable.moveColumn(columnModel.getColumnCount() - 1, indexToMove); + } + // reset the row sorter + individualObservationTable.setAutoCreateRowSorter(true); + + } + + public void setIndividualObservationRows(List<IndividualObservationBatchRowModel> obsRows) { + + model.setIndividualObservationRows(obsRows); + individualObservationTableModel.setRows(obsRows); + model.recomputeIndividualObservationRowsValidateState(); + + } + + public void initCaracteristicValues(SpeciesBatchRowModel speciesBatch) { + + CaracteristicMap sampleCategoryValues = new CaracteristicMap(); + Iterator<SampleCategory<?>> iterator = speciesBatch.iterator(); + iterator.forEachRemaining(sampleCategory -> { + Caracteristic caracteristic = sampleCategory.getCategoryDef().getCaracteristic(); + sampleCategoryValues.put(caracteristic, sampleCategory.getCategoryValue()); + }); + + individualObservationTableModel.setDefaultCaracteristicValues(sampleCategoryValues); + model.setNotEditableCaracteristic(sampleCategoryValues.keySet()); + + } + + public boolean isSampleCodeMenusEnabled(int modelRowIndex) { + return modelRowIndex >= 0 && individualObservationTable.getSelectedRowCount() == 1 + && individualObservationTableModel.getRows().get(individualObservationTable.getSelectedRow()).withSamplingCode(); + } + + public void initObservationsCache(SpeciesBatchRowModel incomingSpeciesBatch, FishingOperation fishingOperation) { + + individualObservationUICache.init(ui, incomingSpeciesBatch, fishingOperation, model.getIndividualObservationRows()); + + } + + public IndividualObservationUICache getIndividualObservationUICache() { + return individualObservationUICache; + } + + public void initMaturityCaracteristic(SpeciesProtocol speciesProtocol) { + + Caracteristic maturityCaracteristic; + + if (speciesProtocol == null) { + maturityCaracteristic = null; + } else { + maturityCaracteristic = maturityCaracteristics.get(speciesProtocol.getMaturityPmfmId()); + } + + // Add maturity column if necessary + + model.setMaturityCaracteristic(maturityCaracteristic); + if (maturityCaracteristic != null) { + addMaturityCaracteristicColumnToModel(maturityCaracteristic); + } + + } + +} + diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/individualobservation/IndividualObservationBatchTableModel.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/IndividualObservationBatchTableModel.java similarity index 78% rename from tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/individualobservation/IndividualObservationBatchTableModel.java rename to tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/IndividualObservationBatchTableModel.java index 8a6a924..690f9e5 100644 --- a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/individualobservation/IndividualObservationBatchTableModel.java +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/IndividualObservationBatchTableModel.java @@ -1,4 +1,4 @@ -package fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation; +package fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency; /* * #%L @@ -23,13 +23,14 @@ package fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservatio */ import fr.ifremer.tutti.persistence.entities.CaracteristicMap; +import fr.ifremer.tutti.persistence.entities.data.CopyIndividualObservationMode; import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValue; import fr.ifremer.tutti.persistence.entities.referential.Species; import fr.ifremer.tutti.service.sampling.SamplingCodePrefix; import fr.ifremer.tutti.type.WeightUnit; -import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.SpeciesFrequencyUIModel; import fr.ifremer.tutti.ui.swing.util.table.CaracteristicColumnIdentifier; +import org.apache.commons.collections4.CollectionUtils; import org.jdesktop.swingx.table.TableColumnModelExt; import org.nuiton.jaxx.application.swing.table.AbstractApplicationTableModel; import org.nuiton.jaxx.application.swing.table.ColumnIdentifier; @@ -37,6 +38,9 @@ import org.nuiton.jaxx.application.swing.table.ColumnIdentifier; import java.beans.PropertyChangeEvent; import java.beans.PropertyChangeListener; import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; import java.util.Set; import java.util.stream.Collectors; @@ -100,16 +104,16 @@ public class IndividualObservationBatchTableModel extends AbstractApplicationTab protected Caracteristic lengthstepCaracteristic; - protected final SpeciesFrequencyUIModel parentModel; + protected final SpeciesFrequencyUIModel uiModel; public IndividualObservationBatchTableModel(WeightUnit weightUnit, - SpeciesFrequencyUIModel parentModel, + SpeciesFrequencyUIModel uiModel, TableColumnModelExt columnModel) { super(columnModel, true, false); - this.parentModel = parentModel; + this.uiModel = uiModel; this.weightUnit = weightUnit; // Lorsque la caracteristique de maturité change, on met à jour defaultCaracteristicsMap - this.parentModel.addPropertyChangeListener(SpeciesFrequencyUIModel.PROPERTY_MATURITY_CARACTERISTIC, new PropertyChangeListener() { + this.uiModel.addPropertyChangeListener(SpeciesFrequencyUIModel.PROPERTY_MATURITY_CARACTERISTIC, new PropertyChangeListener() { @Override public void propertyChange(PropertyChangeEvent evt) { Caracteristic oldValue = (Caracteristic) evt.getOldValue(); @@ -123,7 +127,7 @@ public class IndividualObservationBatchTableModel extends AbstractApplicationTab } }); - this.defaultCaracteristicsMap = CaracteristicMap.fromCollection(parentModel.getDefaultCaracteristic()); + this.defaultCaracteristicsMap = CaracteristicMap.fromCollection(uiModel.getDefaultCaracteristic()); setNoneEditableCols(RANK); } @@ -177,12 +181,12 @@ public class IndividualObservationBatchTableModel extends AbstractApplicationTab if (getRowCount() > 0) { IndividualObservationBatchRowModel lastRow = getRows().get(getRowCount() - 1); - CaracteristicQualitativeValue gender = parentModel.getGender(lastRow); - parentModel.setGenderValueToDefaultCaracterictis(result, gender); + CaracteristicQualitativeValue gender = uiModel.getGender(lastRow); + uiModel.setGenderValueToDefaultCaracterictis(result, gender); - if (parentModel.withMaturityCaracteristic()) { - CaracteristicQualitativeValue maturityState = parentModel.getMaturityValue(lastRow); - parentModel.setMaturityValueToDefaultCaracterictis(result, maturityState); + if (uiModel.withMaturityCaracteristic()) { + CaracteristicQualitativeValue maturityState = uiModel.getMaturityValue(lastRow); + uiModel.setMaturityValueToDefaultCaracterictis(result, maturityState); } } @@ -257,4 +261,43 @@ public class IndividualObservationBatchTableModel extends AbstractApplicationTab } + public List<IndividualObservationBatchRowModel> loadRows(List<IndividualObservationBatchRowModel> individualObservations, PropertyChangeListener individualObservationRowChangedListener) { + + List<IndividualObservationBatchRowModel> obsRows = new ArrayList<>(); + + setRows(new ArrayList<>()); + + if (CollectionUtils.isNotEmpty(individualObservations)) { + + CopyIndividualObservationMode copyIndividualObservationMode = null; + + int rankOrder = 1; + for (IndividualObservationBatchRowModel rowModel : individualObservations) { + + CopyIndividualObservationMode incomingCopyIndividualObservationMode = rowModel.getCopyIndividualObservationMode(); + Objects.requireNonNull(incomingCopyIndividualObservationMode, "Mode de recopie non trouvé sur l'observation individuelle: " + rowModel.getId()); + if (copyIndividualObservationMode == null) { + copyIndividualObservationMode = incomingCopyIndividualObservationMode; + } else { + if (copyIndividualObservationMode != incomingCopyIndividualObservationMode) { + throw new IllegalStateException("Plusieurs modes de recopie trouvés sur les observations individuelles du lot, ce qui est impossible"); + } + } + IndividualObservationBatchRowModel newRow = createNewRow(); + newRow.copy(rowModel); + newRow.setRankOrder(rankOrder++); + newRow.addPropertyChangeListener(individualObservationRowChangedListener); + newRow.setValid(true); + + uiModel.moveMaturityValueFromCaracteristicsToDefaultCaracteristics(newRow); + + obsRows.add(newRow); + } + + } + + return obsRows; + + } + } diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/IndividualObservationUICache.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/IndividualObservationUICache.java index 8dc68e5..1c7f68e 100644 --- a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/IndividualObservationUICache.java +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/IndividualObservationUICache.java @@ -34,7 +34,6 @@ import fr.ifremer.tutti.service.sampling.CruiseSamplingCache; import fr.ifremer.tutti.service.sampling.SamplingCodePrefix; import fr.ifremer.tutti.service.sampling.SamplingEvent; import fr.ifremer.tutti.service.sampling.SamplingListener; -import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.IndividualObservationBatchRowModel; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.edit.SpeciesBatchRowModel; import fr.ifremer.tutti.util.Numbers; import org.apache.commons.logging.Log; diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyCellComponent.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyCellComponent.java index 8c9d1c5..f56112f 100644 --- a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyCellComponent.java +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyCellComponent.java @@ -24,7 +24,6 @@ package fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency; import fr.ifremer.tutti.persistence.entities.data.CopyIndividualObservationMode; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.EditSpeciesBatchPanelUI; -import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.IndividualObservationBatchRowModel; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.edit.SpeciesBatchRowModel; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.edit.SpeciesBatchTableModel; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.edit.SpeciesBatchUI; diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyLogRowModel.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyLogRowModel.java index 109e6e7..c29de3b 100644 --- a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyLogRowModel.java +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyLogRowModel.java @@ -24,7 +24,6 @@ package fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency; * #L% */ -import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.IndividualObservationBatchRowModel; import org.apache.commons.lang3.time.DateFormatUtils; import org.jdesktop.beans.AbstractSerializableBean; diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyTableModel.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyTableModel.java index 38c945c..3cd8750 100644 --- a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyTableModel.java +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyTableModel.java @@ -26,17 +26,17 @@ import com.google.common.base.Preconditions; import com.google.common.collect.Lists; import fr.ifremer.tutti.persistence.entities.data.CopyIndividualObservationMode; import fr.ifremer.tutti.type.WeightUnit; -import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.IndividualObservationBatchRowModel; import fr.ifremer.tutti.util.Weights; +import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.jdesktop.swingx.table.TableColumnModelExt; -import org.jfree.data.xy.XYSeries; import org.nuiton.jaxx.application.swing.table.AbstractApplicationTableModel; import org.nuiton.jaxx.application.swing.table.ColumnIdentifier; import java.beans.PropertyChangeEvent; import java.beans.PropertyChangeListener; +import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Map; @@ -96,9 +96,9 @@ public class SpeciesFrequencyTableModel extends AbstractApplicationTableModel<Sp protected transient PropertyChangeListener onNumberChangedListener; - protected final XYSeries frequenciesSeries; - - protected final XYSeries averageWeightsSeries; +// protected final XYSeries frequenciesSeries; +// +// protected final XYSeries averageWeightsSeries; public SpeciesFrequencyTableModel(WeightUnit weightUnit, WeightUnit individualObservationWeightUnit, @@ -109,8 +109,8 @@ public class SpeciesFrequencyTableModel extends AbstractApplicationTableModel<Sp this.individualObservationWeightUnit = individualObservationWeightUnit; this.uiModel = uiModel; this.modelCache = uiModel.cache; - this.frequenciesSeries = uiModel.frequenciesDataset.getSeries(0); - this.averageWeightsSeries = uiModel.averageWeightsDataset.getSeries(0); +// this.frequenciesSeries = uiModel.getFrequenciesHistogramModel().getDataset().getSeries(0); +// this.averageWeightsSeries = uiModel.getAverageWeightsHistogramModel().getDataset().getSeries(0); setNoneEditableCols(RTP_COMPUTED_WEIGHT); } @@ -277,8 +277,9 @@ public class SpeciesFrequencyTableModel extends AbstractApplicationTableModel<Sp if (oldValue != null) { modelCache.removeLengthStep(oldValue); - removeLengthStepFromSeries(frequenciesSeries, oldValue); - removeLengthStepFromSeries(averageWeightsSeries, oldValue); + lengthStepWasRemoved(oldValue); +// removeLengthStepFromSeries(frequenciesSeries, oldValue); +// removeLengthStepFromSeries(averageWeightsSeries, oldValue); } @@ -287,13 +288,14 @@ public class SpeciesFrequencyTableModel extends AbstractApplicationTableModel<Sp modelCache.addLengthStep(row); - if (row.withNumber()) { - - frequenciesSeries.addOrUpdate(newValue, row.getNumber()); - Float weight = Weights.convert(weightUnit, individualObservationWeightUnit, row.computeAverageWeight()); - averageWeightsSeries.addOrUpdate(newValue, weight); - - } + lengthStepOrNumberWasUpdated(row); +// if (row.withNumber()) { +// +// frequenciesSeries.addOrUpdate(newValue, row.getNumber()); +// Float weight = Weights.convert(weightUnit, individualObservationWeightUnit, row.computeAverageWeight()); +// averageWeightsSeries.addOrUpdate(newValue, weight); +// +// } } @@ -330,14 +332,16 @@ public class SpeciesFrequencyTableModel extends AbstractApplicationTableModel<Sp if (!row.withNumber()) { // remove the value for the lengthStep - removeLengthStepFromSeries(frequenciesSeries, lengthStep); - removeLengthStepFromSeries(averageWeightsSeries, lengthStep); + lengthStepWasRemoved(lengthStep); +// removeLengthStepFromSeries(frequenciesSeries, lengthStep); +// removeLengthStepFromSeries(averageWeightsSeries, lengthStep); } else { - frequenciesSeries.addOrUpdate(lengthStep, row.getNumber()); - Float weight = Weights.convert(weightUnit, individualObservationWeightUnit, row.computeAverageWeight()); - averageWeightsSeries.addOrUpdate(lengthStep, weight); + lengthStepOrNumberWasUpdated(row); +// frequenciesSeries.addOrUpdate(lengthStep, row.getNumber()); +// Float weight = Weights.convert(weightUnit, individualObservationWeightUnit, row.computeAverageWeight()); +// averageWeightsSeries.addOrUpdate(lengthStep, weight); } @@ -374,12 +378,14 @@ public class SpeciesFrequencyTableModel extends AbstractApplicationTableModel<Sp if (!row.withWeight()) { // remove the value for the lengthStep - removeLengthStepFromSeries(averageWeightsSeries, lengthStep); + uiModel.getAverageWeightsHistogramModel().removeValue(lengthStep); +// removeLengthStepFromSeries(averageWeightsSeries, lengthStep); } else { - Float weight = Weights.convert(weightUnit, individualObservationWeightUnit, row.computeAverageWeight()); - averageWeightsSeries.addOrUpdate(lengthStep, weight); + uiModel.getAverageWeightsHistogramModel().addOrUpdate(row); +// Float weight = Weights.convert(weightUnit, individualObservationWeightUnit, row.computeAverageWeight()); +// averageWeightsSeries.addOrUpdate(lengthStep, weight); } @@ -397,15 +403,15 @@ public class SpeciesFrequencyTableModel extends AbstractApplicationTableModel<Sp return onWeightChangedListener; } - private void removeLengthStepFromSeries(XYSeries series, Float lengthStep) { - if (series.indexOf(lengthStep) >= 0) { - if (series.getItemCount() > 1) { - series.remove(lengthStep); - } else { - series.clear(); - } - } - } +// private void removeLengthStepFromSeries(XYSeries series, Float lengthStep) { +// if (series.indexOf(lengthStep) >= 0) { +// if (series.getItemCount() > 1) { +// series.remove(lengthStep); +// } else { +// series.clear(); +// } +// } +// } private void dettachListeners(SpeciesFrequencyRowModel result) { @@ -578,4 +584,43 @@ public class SpeciesFrequencyTableModel extends AbstractApplicationTableModel<Sp } + public List<SpeciesFrequencyRowModel> loadRows(List<SpeciesFrequencyRowModel> incomingRows) { + + List<SpeciesFrequencyRowModel> result = new ArrayList<>(); + + if (CollectionUtils.isNotEmpty(incomingRows)) { + + for (SpeciesFrequencyRowModel rowModel : incomingRows) { + + SpeciesFrequencyRowModel newRow = createNewRow(false, false); + newRow.copy(rowModel); + result.add(newRow); + + } + + } + + return result; + + } + + private void lengthStepWasRemoved(Float lengthStep) { + + uiModel.getAverageWeightsHistogramModel().removeValue(lengthStep); + uiModel.getFrequenciesHistogramModel().removeValue(lengthStep); + + } + + + private void lengthStepOrNumberWasUpdated(SpeciesFrequencyRowModel row) { + + if (row.withNumber()) { + + uiModel.getAverageWeightsHistogramModel().addOrUpdate(row); + uiModel.getFrequenciesHistogramModel().addOrUpdate(row); + + } + + } + } \ No newline at end of file diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyUI.jaxx b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyUI.jaxx index aeeb4ad..dd24f4d 100644 --- a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyUI.jaxx +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyUI.jaxx @@ -118,7 +118,7 @@ protected int getLengthStepPanelPreferedWidth() { <JToolBar id="frequenciesToolBar"> <!-- use actionperformed otherwise the event is triggered twice when the confirm dialog is shown --> <JCheckBox id='copyRtpWeightsCheckBox' onActionPerformed='model.setCopyRtpWeights(copyRtpWeightsCheckBox.isSelected())'/> - <JButton id='graphAverageWeightButton' onActionPerformed="handler.showAverageWeightsHistogram()"/> + <JButton id='graphAverageWeightButton'/> </JToolBar> <JToolBar id="copyToSizeToolBar"> diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyUIHandler.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyUIHandler.java index ebd4104..d163a03 100644 --- a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyUIHandler.java +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyUIHandler.java @@ -22,20 +22,14 @@ package fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency; * #L% */ -import com.google.common.collect.Lists; -import com.google.common.collect.Sets; import fr.ifremer.tutti.ichtyometer.feed.event.FeedReaderEvent; import fr.ifremer.tutti.ichtyometer.feed.event.FeedReaderListener; import fr.ifremer.tutti.ichtyometer.feed.record.FeedReaderMeasureRecord; -import fr.ifremer.tutti.persistence.entities.CaracteristicMap; import fr.ifremer.tutti.persistence.entities.TuttiEntities; -import fr.ifremer.tutti.persistence.entities.data.Attachment; import fr.ifremer.tutti.persistence.entities.data.CopyIndividualObservationMode; -import fr.ifremer.tutti.persistence.entities.data.SampleCategory; import fr.ifremer.tutti.persistence.entities.data.SampleCategoryModel; import fr.ifremer.tutti.persistence.entities.protocol.Rtp; import fr.ifremer.tutti.persistence.entities.protocol.SpeciesProtocol; -import fr.ifremer.tutti.persistence.entities.protocol.TuttiProtocol; import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValue; import fr.ifremer.tutti.persistence.entities.referential.Sexs; @@ -43,13 +37,8 @@ import fr.ifremer.tutti.persistence.entities.referential.Species; import fr.ifremer.tutti.persistence.entities.referential.TaxonCache; import fr.ifremer.tutti.persistence.entities.referential.TaxonCaches; import fr.ifremer.tutti.service.DecoratorService; -import fr.ifremer.tutti.service.sampling.SamplingCodePrefix; import fr.ifremer.tutti.type.WeightUnit; import fr.ifremer.tutti.ui.swing.TuttiUIContext; -import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.IndividualObservationBatchRowModel; -import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.IndividualObservationBatchTableModel; -import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.SamplingCodeCellEditor; -import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.SamplingCodeCellRenderer; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.EditSpeciesBatchPanelUI; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.SpeciesOrBenthosBatchUISupport; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.edit.SpeciesBatchRowModel; @@ -57,24 +46,19 @@ import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.Spe import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.actions.ApplySpeciesFrequencyRafaleAction; import fr.ifremer.tutti.ui.swing.util.SoundEngine; import fr.ifremer.tutti.ui.swing.util.TuttiBeanMonitor; -import fr.ifremer.tutti.ui.swing.util.TuttiNumberTickUnitSource; import fr.ifremer.tutti.ui.swing.util.TuttiUI; import fr.ifremer.tutti.ui.swing.util.TuttiUIUtil; -import fr.ifremer.tutti.ui.swing.util.attachment.AttachmentCellEditor; -import fr.ifremer.tutti.ui.swing.util.attachment.AttachmentCellRenderer; -import fr.ifremer.tutti.ui.swing.util.caracteristics.CaracteristicMapCellComponent; import fr.ifremer.tutti.ui.swing.util.caracteristics.CaracteristicMapColumnRowModel; import fr.ifremer.tutti.ui.swing.util.caracteristics.CaracteristicMapColumnUIHandler; import fr.ifremer.tutti.ui.swing.util.caracteristics.CaracteristicMapEditorUI; -import fr.ifremer.tutti.ui.swing.util.comment.CommentCellEditor; -import fr.ifremer.tutti.ui.swing.util.comment.CommentCellRenderer; import fr.ifremer.tutti.ui.swing.util.table.AbstractTuttiTableUIHandler; import fr.ifremer.tutti.ui.swing.util.table.CaracteristicColumnIdentifier; +import fr.ifremer.tutti.util.Units; import fr.ifremer.tutti.util.Weights; import jaxx.runtime.swing.editor.bean.BeanFilterableComboBox; import jaxx.runtime.validator.swing.SwingValidator; import org.apache.commons.collections4.CollectionUtils; -import org.apache.commons.lang3.StringUtils; +import org.apache.commons.io.IOUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.jdesktop.swingx.JXTable; @@ -84,49 +68,33 @@ import org.jdesktop.swingx.decorator.Highlighter; import org.jdesktop.swingx.table.DefaultTableColumnModelExt; import org.jdesktop.swingx.table.TableColumnExt; import org.jdesktop.swingx.table.TableColumnModelExt; -import org.jfree.chart.ChartFactory; -import org.jfree.chart.ChartPanel; -import org.jfree.chart.JFreeChart; -import org.jfree.chart.axis.NumberTickUnitSource; -import org.jfree.chart.axis.ValueAxis; -import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer; import org.nuiton.decorator.Decorator; import org.nuiton.jaxx.application.ApplicationBusinessException; import org.nuiton.jaxx.application.swing.AbstractApplicationUIHandler; import org.nuiton.jaxx.application.swing.table.ColumnIdentifier; import javax.swing.JComponent; -import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JOptionPane; -import javax.swing.JPanel; import javax.swing.JSplitPane; import javax.swing.JTable; import javax.swing.JTextField; import javax.swing.SwingUtilities; -import javax.swing.event.TableModelEvent; import javax.swing.table.TableCellEditor; import javax.swing.table.TableCellRenderer; import javax.swing.table.TableColumnModel; -import java.awt.BorderLayout; import java.awt.Color; import java.awt.Component; import java.awt.Font; import java.awt.event.KeyAdapter; import java.awt.event.KeyEvent; -import java.awt.event.MouseAdapter; -import java.awt.event.MouseEvent; -import java.beans.PropertyChangeEvent; -import java.beans.PropertyChangeListener; import java.beans.PropertyVetoException; +import java.io.Serializable; import java.util.ArrayList; import java.util.Collections; -import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Objects; -import java.util.Optional; -import java.util.Set; import static org.nuiton.i18n.I18n.t; @@ -149,15 +117,15 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci private Map<String, Caracteristic> lengthStepCaracteristics; - private Map<String, Caracteristic> maturityCaracteristics; +// private Map<String, Caracteristic> maturityCaracteristics; - private JFreeChart frequenciesChart; +// private JFreeChart frequenciesChart; - private JFreeChart averageWeightsChart; +// private JFreeChart averageWeightsChart; - protected final JFrame frequenciesHistogramPopup = new JFrame(); +// protected final JFrame frequenciesHistogramPopup = new JFrame(); - protected final JFrame averageWeightsHistogramPopup = new JFrame(); +// protected final JFrame averageWeightsHistogramPopup = new JFrame(); /** * Weight unit. @@ -171,16 +139,28 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci */ protected final FeedReaderListener feedReaderListener; - protected IndividualObservationUICache individualObservationUICache; +// protected IndividualObservationUICache individualObservationUICache; protected ApplySpeciesFrequencyRafaleAction applySpeciesFrequencyRafaleAction; - protected PropertyChangeListener obsChangedListener; +// /** +// * Added on each individual observation row in the dedicated table. +// * Notify each time a modification is done on a such row. +// */ +// protected PropertyChangeListener individualObservationRowChangedListener; - protected CaracteristicColumnIdentifier<IndividualObservationBatchRowModel> maturityColumnId; +// protected CaracteristicColumnIdentifier<IndividualObservationBatchRowModel> maturityColumnId; protected SpeciesOrBenthosBatchUISupport speciesOrBenthosBatchUISupport; + protected IndividualObservationBatchTableHandler individualObservationBatchTableHandler; + protected AverageWeightsHistogramHandler averageWeightsHistogramHandler; + protected FrequenciesHistogramHandler frequenciesHistogramHandler; + + protected Decorator<Caracteristic> caracteristicDecorator; + protected Decorator<Caracteristic> caracteristicTipDecorator; + protected Decorator<CaracteristicQualitativeValue> caracteristicQualitativeDecorator; + public SpeciesFrequencyUIHandler() { super(SpeciesFrequencyRowModel.PROPERTY_LENGTH_STEP, @@ -205,161 +185,161 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci } }; - - this.obsChangedListener = new PropertyChangeListener() { - - @Override - public void propertyChange(PropertyChangeEvent evt) { - - IndividualObservationBatchRowModel row = (IndividualObservationBatchRowModel) evt.getSource(); - String propertyName = evt.getPropertyName(); - - SpeciesFrequencyUIModel model = getModel(); - - CaracteristicQualitativeValue gender = model.getGender(row); - CaracteristicQualitativeValue maturity = model.getMaturityValue(row); - - switch (propertyName) { - case IndividualObservationBatchRowModel.PROPERTY_SIZE: { - - Float oldValue = (Float) evt.getOldValue(); - Float newValue = (Float) evt.getNewValue(); - - if (oldValue != null) { - individualObservationUICache.decrementsObservationNb(gender, maturity, oldValue, row.getSamplingCode()); - } - if (newValue != null) { - individualObservationUICache.incrementsObservationNb(gender, maturity, newValue, row.getSamplingCode()); - } - - // we only update the frequencies if the row is valid - if (row.isValid() && model.mustCopyIndividualObservationSize()) { - - if (oldValue != null) { - getTableModel().decrementFrequencyRowsNumbers(oldValue); - } - if (newValue != null) { - getTableModel().incrementFrequencyRowsNumbers(newValue); - } - - if (model.isCopyIndividualObservationAll() && row.withWeight()) { - float weight = row.getWeight(); - if (oldValue != null) { - getTableModel().removeWeightToFrequencyRow(oldValue, weight); - } - if (newValue != null) { - getTableModel().addWeightToFrequencyRow(newValue, weight); - } - } - } - } - break; - - case IndividualObservationBatchRowModel.PROPERTY_WEIGHT: - if (row.isValid() && model.isCopyIndividualObservationAll()) { - - Float oldValue = (Float) evt.getOldValue(); - Float newValue = (Float) evt.getNewValue(); - Float weightToAdd; - - if (oldValue == null) { - weightToAdd = newValue; - - } else if (newValue == null) { - weightToAdd = -oldValue; - - } else { - weightToAdd = newValue - oldValue; - } - - if (weightUnit.isNotNullNorZero(weightToAdd)) { - if (weightUnit.isGreaterThanZero(weightToAdd)) { - getTableModel().addWeightToFrequencyRow(row, weightToAdd); - } else { - getTableModel().removeWeightToFrequencyRow(row, -weightToAdd); - } - } - } - break; - - case IndividualObservationBatchRowModel.PROPERTY_DEFAULT_CARACTERISTICS: - case IndividualObservationBatchRowModel.PROPERTY_CARACTERISTICS: - if (row.withSize()) { - CaracteristicMap oldValue = (CaracteristicMap) evt.getOldValue(); - CaracteristicMap newValue = (CaracteristicMap) evt.getNewValue(); - - if (log.isInfoEnabled()) { - log.info("caracteristics changed"); - } - - if (model.withMaturityCaracteristic()) { - CaracteristicQualitativeValue oldMaturity = model.getMaturityValue(oldValue); - CaracteristicQualitativeValue newMaturity = model.getMaturityValue(newValue); - if (log.isInfoEnabled()) { - log.info("maturities : " + oldMaturity + " " + newMaturity); - } - if (!Objects.equals(oldMaturity, newMaturity)) { - individualObservationUICache.decrementsObservationNb(gender, oldMaturity, row.getSize()); - individualObservationUICache.incrementsObservationNb(gender, newMaturity, row.getSize(), row.getSamplingCode()); - } - } - - CaracteristicQualitativeValue oldGender = model.getGender(oldValue); - CaracteristicQualitativeValue newGender = model.getGender(newValue); - if (!Objects.equals(oldGender, newGender)) { - individualObservationUICache.decrementsObservationNb(oldGender, maturity, row.getSize()); - individualObservationUICache.incrementsObservationNb(newGender, maturity, row.getSize(), row.getSamplingCode()); - } - } - break; - - case IndividualObservationBatchRowModel.PROPERTY_SAMPLING_CODE: - if (row.withSize()) { - - float size = row.getSize(); - - String oldValue = (String) evt.getOldValue(); - String newValue = (String) evt.getNewValue(); - - if (StringUtils.isNotBlank(oldValue)) { - individualObservationUICache.decrementsSamplingNb(gender, maturity, size, oldValue); - } - if (StringUtils.isNotBlank(newValue)) { - individualObservationUICache.incrementsSamplingNb(gender, maturity, size, newValue); - } - } - break; - - case IndividualObservationBatchRowModel.PROPERTY_VALID: - // if the row's valid state changes, then remove or readd it to the frequencies - if (!model.isRowComputationInProgress()) { - boolean oldValue = (boolean) evt.getOldValue(); - boolean newValue = (boolean) evt.getNewValue(); - - if (oldValue && model.mustCopyIndividualObservationSize()) { - - getTableModel().decrementFrequencyRowsNumbers(row); - } - if (newValue) { - if (model.mustCopyIndividualObservationSize()) { - getTableModel().incrementFrequencyRowsNumbers(row); - } - if (model.isCopyIndividualObservationAll() && row.withWeight()) { - getTableModel().addWeightToFrequencyRow(row, row.getWeight()); - } - } - } - break; - } - - model.recomputeIndividualObservationRowValidState(row); - model.recomputeCanEditLengthStep(); - - model.setModify(true); - - } - - }; +// // When any change on any individual observation +// this.individualObservationRowChangedListener = new PropertyChangeListener() { +// +// @Override +// public void propertyChange(PropertyChangeEvent evt) { +// +// IndividualObservationBatchRowModel row = (IndividualObservationBatchRowModel) evt.getSource(); +// String propertyName = evt.getPropertyName(); +// +// SpeciesFrequencyUIModel model = getModel(); +// +// CaracteristicQualitativeValue gender = model.getGender(row); +// CaracteristicQualitativeValue maturity = model.getMaturityValue(row); +// +// switch (propertyName) { +// case IndividualObservationBatchRowModel.PROPERTY_SIZE: { +// +// Float oldValue = (Float) evt.getOldValue(); +// Float newValue = (Float) evt.getNewValue(); +// +// if (oldValue != null) { +// individualObservationUICache.decrementsObservationNb(gender, maturity, oldValue, row.getSamplingCode()); +// } +// if (newValue != null) { +// individualObservationUICache.incrementsObservationNb(gender, maturity, newValue, row.getSamplingCode()); +// } +// +// // we only update the frequencies if the row is valid +// if (row.isValid() && model.mustCopyIndividualObservationSize()) { +// +// if (oldValue != null) { +// getTableModel().decrementFrequencyRowsNumbers(oldValue); +// } +// if (newValue != null) { +// getTableModel().incrementFrequencyRowsNumbers(newValue); +// } +// +// if (model.isCopyIndividualObservationAll() && row.withWeight()) { +// float weight = row.getWeight(); +// if (oldValue != null) { +// getTableModel().removeWeightToFrequencyRow(oldValue, weight); +// } +// if (newValue != null) { +// getTableModel().addWeightToFrequencyRow(newValue, weight); +// } +// } +// } +// } +// break; +// +// case IndividualObservationBatchRowModel.PROPERTY_WEIGHT: +// if (row.isValid() && model.isCopyIndividualObservationAll()) { +// +// Float oldValue = (Float) evt.getOldValue(); +// Float newValue = (Float) evt.getNewValue(); +// Float weightToAdd; +// +// if (oldValue == null) { +// weightToAdd = newValue; +// +// } else if (newValue == null) { +// weightToAdd = -oldValue; +// +// } else { +// weightToAdd = newValue - oldValue; +// } +// +// if (weightUnit.isNotNullNorZero(weightToAdd)) { +// if (weightUnit.isGreaterThanZero(weightToAdd)) { +// getTableModel().addWeightToFrequencyRow(row, weightToAdd); +// } else { +// getTableModel().removeWeightToFrequencyRow(row, -weightToAdd); +// } +// } +// } +// break; +// +// case IndividualObservationBatchRowModel.PROPERTY_DEFAULT_CARACTERISTICS: +// case IndividualObservationBatchRowModel.PROPERTY_CARACTERISTICS: +// if (row.withSize()) { +// CaracteristicMap oldValue = (CaracteristicMap) evt.getOldValue(); +// CaracteristicMap newValue = (CaracteristicMap) evt.getNewValue(); +// +// if (log.isInfoEnabled()) { +// log.info("caracteristics changed"); +// } +// +// if (model.withMaturityCaracteristic()) { +// CaracteristicQualitativeValue oldMaturity = model.getMaturityValue(oldValue); +// CaracteristicQualitativeValue newMaturity = model.getMaturityValue(newValue); +// if (log.isInfoEnabled()) { +// log.info("maturities : " + oldMaturity + " " + newMaturity); +// } +// if (!Objects.equals(oldMaturity, newMaturity)) { +// individualObservationUICache.decrementsObservationNb(gender, oldMaturity, row.getSize()); +// individualObservationUICache.incrementsObservationNb(gender, newMaturity, row.getSize(), row.getSamplingCode()); +// } +// } +// +// CaracteristicQualitativeValue oldGender = model.getGender(oldValue); +// CaracteristicQualitativeValue newGender = model.getGender(newValue); +// if (!Objects.equals(oldGender, newGender)) { +// individualObservationUICache.decrementsObservationNb(oldGender, maturity, row.getSize()); +// individualObservationUICache.incrementsObservationNb(newGender, maturity, row.getSize(), row.getSamplingCode()); +// } +// } +// break; +// +// case IndividualObservationBatchRowModel.PROPERTY_SAMPLING_CODE: +// if (row.withSize()) { +// +// float size = row.getSize(); +// +// String oldValue = (String) evt.getOldValue(); +// String newValue = (String) evt.getNewValue(); +// +// if (StringUtils.isNotBlank(oldValue)) { +// individualObservationUICache.decrementsSamplingNb(gender, maturity, size, oldValue); +// } +// if (StringUtils.isNotBlank(newValue)) { +// individualObservationUICache.incrementsSamplingNb(gender, maturity, size, newValue); +// } +// } +// break; +// +// case IndividualObservationBatchRowModel.PROPERTY_VALID: +// // if the row's valid state changes, then remove or readd it to the frequencies +// if (!model.isRowComputationInProgress()) { +// boolean oldValue = (boolean) evt.getOldValue(); +// boolean newValue = (boolean) evt.getNewValue(); +// +// if (oldValue && model.mustCopyIndividualObservationSize()) { +// +// getTableModel().decrementFrequencyRowsNumbers(row); +// } +// if (newValue) { +// if (model.mustCopyIndividualObservationSize()) { +// getTableModel().incrementFrequencyRowsNumbers(row); +// } +// if (model.isCopyIndividualObservationAll() && row.withWeight()) { +// getTableModel().addWeightToFrequencyRow(row, row.getWeight()); +// } +// } +// } +// break; +// } +// +// model.recomputeIndividualObservationRowValidState(row); +// model.recomputeCanEditLengthStep(); +// +// model.setModify(true); +// +// } +// +// }; } @@ -471,13 +451,16 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci this.speciesOrBenthosBatchUISupport = ui.getContextValue(SpeciesOrBenthosBatchUISupport.class, ui.getSpeciesOrBenthosContext()); this.weightUnit = speciesOrBenthosBatchUISupport.getWeightUnit(); + this.caracteristicDecorator = getDecorator(Caracteristic.class, DecoratorService.CARACTERISTIC_PARAMETER_ONLY_WITH_UNIT); + this.caracteristicTipDecorator = getDecorator(Caracteristic.class, DecoratorService.CARACTERISTIC_WITH_UNIT); + this.caracteristicQualitativeDecorator = getDecorator(CaracteristicQualitativeValue.class, null); + Caracteristic sexCaracteristic = getPersistenceService().getSexCaracteristic(); SampleCategoryModel sampleCategoryModel = getDataContext().getSampleCategoryModel(); // get the default caracteristics - List<Caracteristic> defaultCaracteristic = - new ArrayList<>(getDataContext().getDefaultIndividualObservationCaracteristics()); + List<Caracteristic> defaultCaracteristic = new ArrayList<>(getDataContext().getDefaultIndividualObservationCaracteristics()); // on ajoute toujours la colonne sex if (!defaultCaracteristic.contains(sexCaracteristic)) { @@ -505,8 +488,7 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci SwingUtilities.invokeLater(this::updateLogVisibility); }); - this.individualObservationUICache = new IndividualObservationUICache( - getDataContext().getOptionalCruiseSamplingCache().orElse(null), model); +// this.individualObservationUICache = new IndividualObservationUICache(getDataContext().getOptionalCruiseSamplingCache().orElse(null), model); } @Override @@ -516,21 +498,19 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci initUI(this.ui); - List<Caracteristic> lengthStepCaracteristics = - Lists.newArrayList(getDataContext().getLengthStepCaracteristics()); + List<Caracteristic> lengthStepCaracteristics = new ArrayList<>(getDataContext().getLengthStepCaracteristics()); this.lengthStepCaracteristics = TuttiEntities.splitById(lengthStepCaracteristics); - List<Caracteristic> maturityCaracteristics = - Lists.newArrayList(getDataContext().getMaturityCaracteristics()); - - this.maturityCaracteristics = TuttiEntities.splitById(maturityCaracteristics); +// List<Caracteristic> maturityCaracteristics = new ArrayList<>(getDataContext().getMaturityCaracteristics()); +// +// this.maturityCaracteristics = TuttiEntities.splitById(maturityCaracteristics); SpeciesFrequencyUIModel model = getModel(); taxonCache = TaxonCaches.createSpeciesCacheWithoutVernacularCode(getPersistenceService(), getDataContext().getProtocol()); - final Caracteristic modelCaracteristic = model.getLengthStepCaracteristic(); + Caracteristic modelCaracteristic = model.getLengthStepCaracteristic(); initBeanFilterableComboBox(this.ui.getLengthStepCaracteristicComboBox(), lengthStepCaracteristics, modelCaracteristic); @@ -565,10 +545,10 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci // get step from the pmfm float step1 = getStep(newValue); model.setStep(step1); - model.setDataSetIntervalWidth(step1); +// model.setDataSetIntervalWidth(step1); - frequenciesChart.getXYPlot().getDomainAxis().setStandardTickUnits(new TuttiNumberTickUnitSource(step1 == 1f)); - averageWeightsChart.getXYPlot().getDomainAxis().setStandardTickUnits(new TuttiNumberTickUnitSource(step1 == 1f)); +// frequenciesChart.getXYPlot().getDomainAxis().setStandardTickUnits(new TuttiNumberTickUnitSource(step1 == 1f)); +// averageWeightsChart.getXYPlot().getDomainAxis().setStandardTickUnits(new TuttiNumberTickUnitSource(step1 == 1f)); if (CollectionUtils.isNotEmpty(getModel().getRows())) { for (SpeciesFrequencyRowModel rowModel : getModel().getRows()) { @@ -578,7 +558,7 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci } SpeciesFrequencyUIHandler.this.ui.getValidator().doValidate(); - getObsTableModel().setLengthstepCaracteristic(newValue); +// getObsTableModel().setLengthstepCaracteristic(newValue); }); // when lengthStepCaracteristicUnit changed, let's updates the label of some fields @@ -591,26 +571,26 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci unit = t("tutti.editSpeciesFrequencies.unkownStepUnit"); } - getUI().getMinStepLabel().setText(getLabelWithUnit(t("tutti.editSpeciesFrequencies.field.minStep"), unit)); - getUI().getMinStepLabel().setToolTipText(getLabelWithUnit(t("tutti.editSpeciesFrequencies.field.minStep.tip"), unit)); + getUI().getMinStepLabel().setText(Units.getLabelWithUnit(t("tutti.editSpeciesFrequencies.field.minStep"), unit)); + getUI().getMinStepLabel().setToolTipText(Units.getLabelWithUnit(t("tutti.editSpeciesFrequencies.field.minStep.tip"), unit)); - getUI().getMaxStepLabel().setText(getLabelWithUnit(t("tutti.editSpeciesFrequencies.field.maxStep"), unit)); - getUI().getMaxStepLabel().setToolTipText(getLabelWithUnit(t("tutti.editSpeciesFrequencies.field.maxStep.tip"), unit)); + getUI().getMaxStepLabel().setText(Units.getLabelWithUnit(t("tutti.editSpeciesFrequencies.field.maxStep"), unit)); + getUI().getMaxStepLabel().setToolTipText(Units.getLabelWithUnit(t("tutti.editSpeciesFrequencies.field.maxStep.tip"), unit)); - getUI().getRafaleStepLabel().setText(getLabelWithUnit(t("tutti.editSpeciesFrequencies.field.rafaleStep"), unit)); - getUI().getRafaleStepLabel().setToolTipText(getLabelWithUnit(t("tutti.editSpeciesFrequencies.field.rafaleStep.tip"), unit)); + getUI().getRafaleStepLabel().setText(Units.getLabelWithUnit(t("tutti.editSpeciesFrequencies.field.rafaleStep"), unit)); + getUI().getRafaleStepLabel().setToolTipText(Units.getLabelWithUnit(t("tutti.editSpeciesFrequencies.field.rafaleStep.tip"), unit)); TableColumnExt column = (TableColumnExt) getUI().getTable().getColumn(SpeciesFrequencyTableModel.LENGTH_STEP); - String lengthStepLabelWithUnit = getLabelWithUnit(t("tutti.editSpeciesFrequencies.table.header.lengthStep"), unit); + String lengthStepLabelWithUnit = Units.getLabelWithUnit(t("tutti.editSpeciesFrequencies.table.header.lengthStep"), unit); column.setHeaderValue(lengthStepLabelWithUnit); column.setToolTipText(lengthStepLabelWithUnit); column = (TableColumnExt) getUI().getObsTable().getColumn(IndividualObservationBatchTableModel.SIZE); - column.setHeaderValue(getLabelWithUnit(t("tutti.editIndividualObservationBatch.table.header.size"), unit)); - column.setToolTipText(getLabelWithUnit(t("tutti.editIndividualObservationBatch.table.header.size"), unit)); + column.setHeaderValue(Units.getLabelWithUnit(t("tutti.editIndividualObservationBatch.table.header.size"), unit)); + column.setToolTipText(Units.getLabelWithUnit(t("tutti.editIndividualObservationBatch.table.header.size"), unit)); - frequenciesChart.getXYPlot().getDomainAxis().setLabel(lengthStepLabelWithUnit); - averageWeightsChart.getXYPlot().getDomainAxis().setLabel(lengthStepLabelWithUnit); +// frequenciesChart.getXYPlot().getDomainAxis().setLabel(lengthStepLabelWithUnit); +// averageWeightsChart.getXYPlot().getDomainAxis().setLabel(lengthStepLabelWithUnit); }); // when configuration mode change, let's focus the best component (see http://forge.codelutin.com/issues/4035) @@ -662,111 +642,111 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci getTableModel().fireTableDataChanged(); }); - model.addPropertyChangeListener(SpeciesFrequencyUIModel.PROPERTY_INDIVIDUAL_OBSERVATION_ROWS, evt -> { - getObsTableModel().setRows((List<IndividualObservationBatchRowModel>) evt.getNewValue()); - }); - - // Pour bloquer le changement du mode de recopie des observations individuelles → mensurations - model.addVetoableChangeListener(SpeciesFrequencyUIModel.PROPERTY_COPY_INDIVIDUAL_OBSERVATION_MODE, evt -> { - - SpeciesFrequencyUIModel source = (SpeciesFrequencyUIModel) evt.getSource(); - CopyIndividualObservationMode oldCopyMode = (CopyIndividualObservationMode) evt.getOldValue(); - CopyIndividualObservationMode newCopyMode = (CopyIndividualObservationMode) evt.getNewValue(); - - if (source.isInitBatchEdition()) { - - if (log.isInfoEnabled()) { - log.info("Skip ask user to confirm copyIndividualObservationMode changed from " + oldCopyMode + " to " + newCopyMode); - } - return; - } - - // le seul mode où l'utilisateur ne peut rien saisir est le mode tout - if (CopyIndividualObservationMode.ALL != oldCopyMode) { - - long rowsWithUserData; - - // si on etait en mode taille et que l'utilisateur avait saisi des tailles - if (oldCopyMode == CopyIndividualObservationMode.SIZE) { - rowsWithUserData = model.getRows().stream() - .filter(SpeciesFrequencyRowModel::withWeight) - .count(); - - } else { - rowsWithUserData = model.getRows().stream() - .filter(row -> row.getLengthStep() != null || row.withNumber() || row.withWeight()) - .count(); - } - - if (rowsWithUserData > 0) { - - String htmlMessage = String.format( - CONFIRMATION_FORMAT, - t("tutti.editSpeciesFrequencies.changeCopyMode.confirm.message"), - t("tutti.editSpeciesFrequencies.changeCopyMode.confirm.help")); - int i = JOptionPane.showConfirmDialog( - getTopestUI(), - htmlMessage, - t("tutti.editSpeciesFrequencies.changeCopyMode.confirm.title"), - JOptionPane.OK_CANCEL_OPTION, - JOptionPane.QUESTION_MESSAGE); - - if (i == JOptionPane.CANCEL_OPTION) { - throw new PropertyVetoException("The user does not want to erase his data.", evt); - } - } - } - }); - - // Pour mettre à jour les mensuratuibs suite au changement du mode de recopie des observations individuelles - model.addPropertyChangeListener(SpeciesFrequencyUIModel.PROPERTY_COPY_INDIVIDUAL_OBSERVATION_MODE, evt -> { - - SpeciesFrequencyUIModel source = (SpeciesFrequencyUIModel) evt.getSource(); - CopyIndividualObservationMode oldCopyMode = (CopyIndividualObservationMode) evt.getOldValue(); - CopyIndividualObservationMode newCopyMode = (CopyIndividualObservationMode) evt.getNewValue(); - - if (newCopyMode == null) { - - return; - } - boolean nothingCopyMode = CopyIndividualObservationMode.NOTHING == newCopyMode; - - - if (!nothingCopyMode) { - - source.setFrequenciesConfigurationMode(FrequencyConfigurationMode.RAFALE); - source.setAddIndividualObservationOnRafale(true); - - } - - - // si on est en initialisation, ca ne sert à rien de regénérer les lignes, elles sont sensées être chargées - if (source.isInitBatchEdition()) { - - if (log.isInfoEnabled()) { - log.info("Skip recompute frequencies from indivudal observations (flag initBatchEdition is on), copyIndividualObservationMode changed from " + oldCopyMode + " to " + newCopyMode); - } - return; - } - - model.setRowComputationInProgress(true); - - try { - - model.getRows().clear(); - model.getRowsInError().clear(); - model.reloadRows(); - model.recomputeIndividualObservationRowsValidateState(); - reloadRowsFromIndividualObservations(); - - } finally { - model.setRowComputationInProgress(false); - } - - getTableModel().fireTableDataChanged(); - getObsTableModel().fireTableDataChanged(); - - }); +// model.addPropertyChangeListener(SpeciesFrequencyUIModel.PROPERTY_INDIVIDUAL_OBSERVATION_ROWS, evt -> { +// getObsTableModel().setRows((List<IndividualObservationBatchRowModel>) evt.getNewValue()); +// }); +// +// // Pour bloquer le changement du mode de recopie des observations individuelles → mensurations +// model.addVetoableChangeListener(SpeciesFrequencyUIModel.PROPERTY_COPY_INDIVIDUAL_OBSERVATION_MODE, evt -> { +// +// SpeciesFrequencyUIModel source = (SpeciesFrequencyUIModel) evt.getSource(); +// CopyIndividualObservationMode oldCopyMode = (CopyIndividualObservationMode) evt.getOldValue(); +// CopyIndividualObservationMode newCopyMode = (CopyIndividualObservationMode) evt.getNewValue(); +// +// if (source.isInitBatchEdition()) { +// +// if (log.isInfoEnabled()) { +// log.info("Skip ask user to confirm copyIndividualObservationMode changed from " + oldCopyMode + " to " + newCopyMode); +// } +// return; +// } +// +// // le seul mode où l'utilisateur ne peut rien saisir est le mode tout +// if (CopyIndividualObservationMode.ALL != oldCopyMode) { +// +// long rowsWithUserData; +// +// // si on etait en mode taille et que l'utilisateur avait saisi des tailles +// if (oldCopyMode == CopyIndividualObservationMode.SIZE) { +// rowsWithUserData = model.getRows().stream() +// .filter(SpeciesFrequencyRowModel::withWeight) +// .count(); +// +// } else { +// rowsWithUserData = model.getRows().stream() +// .filter(row -> row.getLengthStep() != null || row.withNumber() || row.withWeight()) +// .count(); +// } +// +// if (rowsWithUserData > 0) { +// +// String htmlMessage = String.format( +// CONFIRMATION_FORMAT, +// t("tutti.editSpeciesFrequencies.changeCopyMode.confirm.message"), +// t("tutti.editSpeciesFrequencies.changeCopyMode.confirm.help")); +// int i = JOptionPane.showConfirmDialog( +// getTopestUI(), +// htmlMessage, +// t("tutti.editSpeciesFrequencies.changeCopyMode.confirm.title"), +// JOptionPane.OK_CANCEL_OPTION, +// JOptionPane.QUESTION_MESSAGE); +// +// if (i == JOptionPane.CANCEL_OPTION) { +// throw new PropertyVetoException("The user does not want to erase his data.", evt); +// } +// } +// } +// }); +// +// // Pour mettre à jour les mensuratuibs suite au changement du mode de recopie des observations individuelles +// model.addPropertyChangeListener(SpeciesFrequencyUIModel.PROPERTY_COPY_INDIVIDUAL_OBSERVATION_MODE, evt -> { +// +// SpeciesFrequencyUIModel source = (SpeciesFrequencyUIModel) evt.getSource(); +// CopyIndividualObservationMode oldCopyMode = (CopyIndividualObservationMode) evt.getOldValue(); +// CopyIndividualObservationMode newCopyMode = (CopyIndividualObservationMode) evt.getNewValue(); +// +// if (newCopyMode == null) { +// +// return; +// } +// boolean nothingCopyMode = CopyIndividualObservationMode.NOTHING == newCopyMode; +// +// +// if (!nothingCopyMode) { +// +// source.setFrequenciesConfigurationMode(FrequencyConfigurationMode.RAFALE); +// source.setAddIndividualObservationOnRafale(true); +// +// } +// +// +// // si on est en initialisation, ca ne sert à rien de regénérer les lignes, elles sont sensées être chargées +// if (source.isInitBatchEdition()) { +// +// if (log.isInfoEnabled()) { +// log.info("Skip recompute frequencies from indivudal observations (flag initBatchEdition is on), copyIndividualObservationMode changed from " + oldCopyMode + " to " + newCopyMode); +// } +// return; +// } +// +// model.setRowComputationInProgress(true); +// +// try { +// +// model.getRows().clear(); +// model.getRowsInError().clear(); +// model.reloadRows(); +// model.recomputeIndividualObservationRowsValidateState(); +// reloadRowsFromIndividualObservations(); +// +// } finally { +// model.setRowComputationInProgress(false); +// } +// +// getTableModel().fireTableDataChanged(); +// getObsTableModel().fireTableDataChanged(); +// +// }); // set the pattern to the weight in simple counting mode according to the weight unit @@ -774,30 +754,32 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci // init histogram - initFrequenciesHistogram(); +// initFrequenciesHistogram(); // init data table initDataTable(); - initAverageWeightsHistogram(); +// initAverageWeightsHistogram(); // init log table initLogTable(); - initObsTable(); + this.individualObservationBatchTableHandler = new IndividualObservationBatchTableHandler(ui); + this.averageWeightsHistogramHandler = new AverageWeightsHistogramHandler(ui); + this.frequenciesHistogramHandler = new FrequenciesHistogramHandler(ui); listenValidatorValid(ui.getValidator(), model); } - protected IndividualObservationBatchTableModel getObsTableModel() { - return (IndividualObservationBatchTableModel) ui.getObsTable().getModel(); - } +// protected IndividualObservationBatchTableModel getObsTableModel() { +// return (IndividualObservationBatchTableModel) ui.getObsTable().getModel(); +// } - public void showAverageWeightsHistogram() { - averageWeightsHistogramPopup.setVisible(true); - } +// public void showAverageWeightsHistogram() { +// averageWeightsHistogramPopup.setVisible(true); +// } @Override protected JComponent getComponentToFocus() { @@ -819,9 +801,14 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci model.setCanDisplayNotifications(false); - frequenciesHistogramPopup.dispose(); - averageWeightsHistogramPopup.dispose(); - resetSamplingLabel(); +// frequenciesHistogramPopup.dispose(); +// averageWeightsHistogramPopup.dispose(); + + IOUtils.closeQuietly(individualObservationBatchTableHandler); + IOUtils.closeQuietly(averageWeightsHistogramHandler); + IOUtils.closeQuietly(frequenciesHistogramHandler); + +// resetSamplingLabel(); frequencyEditor = null; @@ -834,12 +821,6 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci model.setSimpleCount(null); model.setModify(false); - EditSpeciesBatchPanelUI parent = getParentContainer(EditSpeciesBatchPanelUI.class); - parent.switchToEditBatch(); - - // on supprime la colonne maturité en fermant, pour avoir les même colonnes qu'à la création de l'écran (important pour la swing session) - removeMaturityColumnIfPresent(); - TuttiUIContext context = getContext(); if (context.isIchtyometerConnected()) { @@ -847,7 +828,13 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci context.getIchtyometerReader().removeFeedModeReaderListener(feedReaderListener); } - individualObservationUICache.close(); + EditSpeciesBatchPanelUI parent = getParentContainer(EditSpeciesBatchPanelUI.class); + parent.switchToEditBatch(); + +// // on supprime la colonne maturité en fermant, pour avoir les même colonnes qu'à la création de l'écran (important pour la swing session) +// removeMaturityColumnIfPresent(); +// +// individualObservationUICache.close(); } @@ -857,17 +844,22 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci Objects.requireNonNull(speciesBatch, "Impossible d'éditer un lot non renseigné"); // on enlève la colonne spécifique à l'espèce précédente - removeMaturityColumnIfPresent(); + individualObservationBatchTableHandler.removeMaturityColumnIfPresent(); - if (title != null) { + SpeciesFrequencyUIModel model = getModel(); - frequenciesHistogramPopup.setTitle(title + t("tutti.editSpeciesFrequencies.title")); - averageWeightsHistogramPopup.setTitle(title + weightUnit.decorateLabel(t("tutti.editSpeciesFrequencies.field.graphAverageWeight"))); + Objects.requireNonNull(title, "title can't be null here ?!"); +// if (title != null) { - } + model.getAverageWeightsHistogramModel().setTitle(title); + model.getFrequenciesHistogramModel().setTitle(title); +// frequenciesHistogramPopup.setTitle(title + t("tutti.editSpeciesFrequencies.title")); +// averageWeightsHistogramPopup.setTitle(title + weightUnit.decorateLabel(t("tutti.editSpeciesFrequencies.field.graphAverageWeight"))); + +// } frequencyEditor = editor; - SpeciesFrequencyUIModel model = getModel(); + model.setNextEditableRowIndex(frequencyEditor.getNextEditableRowIndex()); @@ -887,50 +879,79 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci model.setCopyRtpWeights(false); model.setAddIndividualObservationOnRafale(false); - Optional<String> speciesMaturityPmfmId = Optional.empty(); + // get species from protocol + SpeciesProtocol speciesProtocol = getDataContext().isProtocolFilled() ? speciesOrBenthosBatchUISupport.getSpeciesProtocol(speciesBatch.getSpecies()) : null; - // set rtps - TuttiProtocol protocol = getDataContext().getProtocol(); - if (protocol != null) { + // set rtp + Rtp rtp = null; - Integer referenceTaxonId = speciesBatch.getSpecies().getReferenceTaxonId(); - Optional<SpeciesProtocol> optSpeciesProtocol = - protocol.getSpecies().stream() - .filter(sp -> sp.getSpeciesReferenceTaxonId().equals(referenceTaxonId)) - .findFirst(); + if (speciesProtocol != null) { - if (optSpeciesProtocol.isPresent()) { - SpeciesProtocol speciesProtocol = optSpeciesProtocol.get(); - Rtp rtp; - CaracteristicQualitativeValue sampleCategoryValue = (CaracteristicQualitativeValue) speciesBatch.getSampleCategoryValue(getModel().getSexCaracteristic().getIdAsInt()); + CaracteristicQualitativeValue sampleCategoryValue = (CaracteristicQualitativeValue) speciesBatch.getSampleCategoryValue(getModel().getSexCaracteristic().getIdAsInt()); - if (sampleCategoryValue != null) { - - if (Sexs.isMale(sampleCategoryValue)) { - rtp = speciesProtocol.getRtpMale(); - } else if (Sexs.isFemale(sampleCategoryValue)) { - rtp = speciesProtocol.getRtpFemale(); - } else { - rtp = speciesProtocol.getRtpUndefined(); - } + if (sampleCategoryValue != null) { + if (Sexs.isMale(sampleCategoryValue)) { + rtp = speciesProtocol.getRtpMale(); + } else if (Sexs.isFemale(sampleCategoryValue)) { + rtp = speciesProtocol.getRtpFemale(); } else { rtp = speciesProtocol.getRtpUndefined(); } - getModel().setRtp(rtp); - speciesMaturityPmfmId = Optional.ofNullable(speciesProtocol.getMaturityPmfmId()); + } else { + rtp = speciesProtocol.getRtpUndefined(); } } - // Add maturity column if necessary + getModel().setRtp(rtp); + + // init maturity caracteristic + individualObservationBatchTableHandler.initMaturityCaracteristic(speciesProtocol); + +// Optional<String> optionalMaturityPmfmId; +// Optional<SpeciesProtocol> optSpeciesProtocol = +// protocol.getSpecies().stream() +// .filter(sp -> sp.getSpeciesReferenceTaxonId().equals(referenceTaxonId)) +// .findFirst(); +// +// if (optSpeciesProtocol.isPresent()) { +// SpeciesProtocol speciesProtocol = optSpeciesProtocol.get(); +// Rtp rtp; +// CaracteristicQualitativeValue sampleCategoryValue = (CaracteristicQualitativeValue) speciesBatch.getSampleCategoryValue(getModel().getSexCaracteristic().getIdAsInt()); +// +// if (sampleCategoryValue != null) { +// +// if (Sexs.isMale(sampleCategoryValue)) { +// rtp = speciesProtocol.getRtpMale(); +// } else if (Sexs.isFemale(sampleCategoryValue)) { +// rtp = speciesProtocol.getRtpFemale(); +// } else { +// rtp = speciesProtocol.getRtpUndefined(); +// } +// +// } else { +// rtp = speciesProtocol.getRtpUndefined(); +// } +// getModel().setRtp(rtp); +// +// speciesMaturityPmfmId = Optional.ofNullable(speciesProtocol.getMaturityPmfmId()); +// } + +// } +// +// // Add maturity column if necessary +// +// Optional<Caracteristic> optionalMaturityCaracteristic = speciesMaturityPmfmId.map(maturityCaracteristics::get); +// +// setMaturityCaracteristic(optionalMaturityCaracteristic.orElse(null)); - Optional<Caracteristic> optionalMaturityCaracteristic = speciesMaturityPmfmId.map(maturityCaracteristics::get); + loadFrequenciesAndObservations(frequency, individualObservations); - setMaturityCaracteristic(optionalMaturityCaracteristic.orElse(null)); + individualObservationBatchTableHandler.initObservationsCache(frequencyEditor.getEditRow(), getDataContext().getFishingOperation()); - loadFrequenciesAndObservations(frequency, individualObservations); +// individualObservationUICache.init(ui, frequencyEditor.getEditRow(), getDataContext().getFishingOperation(), model.getIndividualObservationRows()); if (getContext().isIchtyometerConnected()) { @@ -939,8 +960,6 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci } - individualObservationUICache.init(ui, frequencyEditor.getEditRow(), getDataContext().getFishingOperation(), model.getIndividualObservationRows()); - model.setModify(false); } finally { @@ -971,7 +990,7 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci } public IndividualObservationUICache getIndividualObservationUICache() { - return individualObservationUICache; + return individualObservationBatchTableHandler.getIndividualObservationUICache(); } //------------------------------------------------------------------------// @@ -1086,81 +1105,81 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci } - protected void initFrequenciesHistogram() { - frequenciesChart = ChartFactory.createXYBarChart(null, - t("tutti.editSpeciesFrequencies.table.header.lengthStep"), - false, - t("tutti.editSpeciesFrequencies.table.header.number"), - getModel().frequenciesDataset); - frequenciesChart.clearSubtitles(); - - ValueAxis rangeAxis = frequenciesChart.getXYPlot().getRangeAxis(); - rangeAxis.setAutoRange(true); - rangeAxis.setStandardTickUnits(new NumberTickUnitSource(true)); - - ValueAxis domainAxis = frequenciesChart.getXYPlot().getDomainAxis(); - domainAxis.setAutoRange(true); - domainAxis.setStandardTickUnits(new TuttiNumberTickUnitSource(true)); - domainAxis.setMinorTickMarksVisible(true); - - frequenciesChart.getXYPlot().getRenderer().setSeriesPaint(0, getConfig().getColorComputedWeights()); - - final ChartPanel chartPanel = new ChartPanel(frequenciesChart); - chartPanel.setDomainZoomable(false); - chartPanel.setMouseZoomable(false); - chartPanel.setPopupMenu(null); - - JPanel histogramPanel = ui.getHistogramPanel(); - histogramPanel.add(chartPanel, BorderLayout.CENTER); - - chartPanel.addMouseListener(new MouseAdapter() { - - @Override - public void mouseClicked(MouseEvent e) { - super.mouseClicked(e); - if (e.getClickCount() > 1) { - - frequenciesHistogramPopup.getContentPane().removeAll(); - ChartPanel chartPanel = new ChartPanel(frequenciesChart); - frequenciesHistogramPopup.getContentPane().add(chartPanel); - frequenciesHistogramPopup.pack(); - frequenciesHistogramPopup.setVisible(true); - - } - } - }); - } - - protected void initAverageWeightsHistogram() { - averageWeightsChart = ChartFactory.createXYLineChart(null, - t("tutti.editSpeciesFrequencies.table.header.lengthStep"), - getConfig().getIndividualObservationWeightUnit() - .decorateLabel(t("tutti.editSpeciesFrequencies.averageWeight.label")), - getModel().averageWeightsDataset); - averageWeightsChart.clearSubtitles(); - - ValueAxis rangeAxis = averageWeightsChart.getXYPlot().getRangeAxis(); - rangeAxis.setAutoRange(true); - rangeAxis.setStandardTickUnits(new NumberTickUnitSource()); - rangeAxis.setMinorTickMarksVisible(true); - - ValueAxis domainAxis = averageWeightsChart.getXYPlot().getDomainAxis(); - domainAxis.setAutoRange(true); - domainAxis.setStandardTickUnits(new TuttiNumberTickUnitSource(true)); - domainAxis.setMinorTickMarksVisible(true); - - XYLineAndShapeRenderer plotRenderer = (XYLineAndShapeRenderer) averageWeightsChart.getXYPlot().getRenderer(); - plotRenderer.setSeriesPaint(0, getConfig().getColorComputedWeights()); - plotRenderer.setBaseShapesVisible(true); - - final ChartPanel chartPanel = new ChartPanel(averageWeightsChart); - chartPanel.setDomainZoomable(false); - chartPanel.setMouseZoomable(false); - chartPanel.setPopupMenu(null); - - averageWeightsHistogramPopup.getContentPane().add(chartPanel); - averageWeightsHistogramPopup.pack(); - } +// protected void initFrequenciesHistogram() { +// frequenciesChart = ChartFactory.createXYBarChart(null, +// t("tutti.editSpeciesFrequencies.table.header.lengthStep"), +// false, +// t("tutti.editSpeciesFrequencies.table.header.number"), +// getModel().frequenciesDataset); +// frequenciesChart.clearSubtitles(); +// +// ValueAxis rangeAxis = frequenciesChart.getXYPlot().getRangeAxis(); +// rangeAxis.setAutoRange(true); +// rangeAxis.setStandardTickUnits(new NumberTickUnitSource(true)); +// +// ValueAxis domainAxis = frequenciesChart.getXYPlot().getDomainAxis(); +// domainAxis.setAutoRange(true); +// domainAxis.setStandardTickUnits(new TuttiNumberTickUnitSource(true)); +// domainAxis.setMinorTickMarksVisible(true); +// +// frequenciesChart.getXYPlot().getRenderer().setSeriesPaint(0, getConfig().getColorComputedWeights()); +// +// final ChartPanel chartPanel = new ChartPanel(frequenciesChart); +// chartPanel.setDomainZoomable(false); +// chartPanel.setMouseZoomable(false); +// chartPanel.setPopupMenu(null); +// +// JPanel histogramPanel = ui.getHistogramPanel(); +// histogramPanel.add(chartPanel, BorderLayout.CENTER); +// +// chartPanel.addMouseListener(new MouseAdapter() { +// +// @Override +// public void mouseClicked(MouseEvent e) { +// super.mouseClicked(e); +// if (e.getClickCount() > 1) { +// +// frequenciesHistogramPopup.getContentPane().removeAll(); +// ChartPanel chartPanel = new ChartPanel(frequenciesChart); +// frequenciesHistogramPopup.getContentPane().add(chartPanel); +// frequenciesHistogramPopup.pack(); +// frequenciesHistogramPopup.setVisible(true); +// +// } +// } +// }); +// } + +// protected void initAverageWeightsHistogram() { +// averageWeightsChart = ChartFactory.createXYLineChart(null, +// t("tutti.editSpeciesFrequencies.table.header.lengthStep"), +// getConfig().getIndividualObservationWeightUnit() +// .decorateLabel(t("tutti.editSpeciesFrequencies.averageWeight.label")), +// getModel().averageWeightsDataset); +// averageWeightsChart.clearSubtitles(); +// +// ValueAxis rangeAxis = averageWeightsChart.getXYPlot().getRangeAxis(); +// rangeAxis.setAutoRange(true); +// rangeAxis.setStandardTickUnits(new NumberTickUnitSource()); +// rangeAxis.setMinorTickMarksVisible(true); +// +// ValueAxis domainAxis = averageWeightsChart.getXYPlot().getDomainAxis(); +// domainAxis.setAutoRange(true); +// domainAxis.setStandardTickUnits(new TuttiNumberTickUnitSource(true)); +// domainAxis.setMinorTickMarksVisible(true); +// +// XYLineAndShapeRenderer plotRenderer = (XYLineAndShapeRenderer) averageWeightsChart.getXYPlot().getRenderer(); +// plotRenderer.setSeriesPaint(0, getConfig().getColorComputedWeights()); +// plotRenderer.setBaseShapesVisible(true); +// +// final ChartPanel chartPanel = new ChartPanel(averageWeightsChart); +// chartPanel.setDomainZoomable(false); +// chartPanel.setMouseZoomable(false); +// chartPanel.setPopupMenu(null); +// +// averageWeightsHistogramPopup.getContentPane().add(chartPanel); +// averageWeightsHistogramPopup.pack(); +// } protected void initLogTable() { JXTable logTable = ui.getLogsTable(); @@ -1190,184 +1209,185 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci logTable.addHighlighter(evenHighlighter); } - protected void initObsTable() { - - JXTable obsTable = ui.getObsTable(); - - // can show / hide some columns in model - obsTable.setColumnControlVisible(true); - - // create obsTable column model - DefaultTableColumnModelExt columnModel = new DefaultTableColumnModelExt(); - Decorator<Caracteristic> caracteristicDecorator = - getDecorator(Caracteristic.class, DecoratorService.CARACTERISTIC_PARAMETER_ONLY_WITH_UNIT); - Decorator<Caracteristic> caracteristicTipDecorator = - getDecorator(Caracteristic.class, DecoratorService.CARACTERISTIC_WITH_UNIT); - - Decorator<CaracteristicQualitativeValue> caracteristicQualitativeDecorator = - getDecorator(CaracteristicQualitativeValue.class, null); - - { - // Rank column - - addIntegerColumnToModel(columnModel, - IndividualObservationBatchTableModel.RANK, - TuttiUI.INT_10_DIGITS_PATTERN, - obsTable); - - } - - { // Size column - - addFloatColumnToModel(columnModel, - IndividualObservationBatchTableModel.SIZE, - TuttiUI.DECIMAL3_PATTERN, - obsTable); - } - - WeightUnit individualObservationWeightUnit = getConfig().getIndividualObservationWeightUnit(); - - { // Weight column - - addFloatColumnToModel(columnModel, - IndividualObservationBatchTableModel.WEIGHT, - individualObservationWeightUnit, - obsTable); - } - - List<Caracteristic> defaultCaracteristic = getModel().getDefaultCaracteristic(); - - for (Caracteristic caracteristic : defaultCaracteristic) { - addCaracteristicColumnToModel(obsTable, - columnModel, - caracteristicDecorator, - caracteristicTipDecorator, - caracteristicQualitativeDecorator, - caracteristic); - } - - { // Other caracteristics column - - Set<Caracteristic> caracteristicsToSkip = Collections.unmodifiableSet( - Sets.newHashSet(getModel().getDefaultCaracteristic())); - - addColumnToModel(columnModel, - CaracteristicMapCellComponent.newEditor(ui, caracteristicsToSkip), - CaracteristicMapCellComponent.newRender(getContext()), - IndividualObservationBatchTableModel.OTHER_CARACTERISTICS); - - } - - { - // Smapling code column - - addColumnToModel(columnModel, - SamplingCodeCellEditor.newEditor(ui), - SamplingCodeCellRenderer.newRender(), - IndividualObservationBatchTableModel.SAMPLING_CODE); - - } - - { // Comment column - - addColumnToModel(columnModel, - CommentCellEditor.newEditor(ui), - CommentCellRenderer.newRender(), - IndividualObservationBatchTableModel.COMMENT); - - } - - { // File column - - addColumnToModel(columnModel, - AttachmentCellEditor.newEditor(ui), - AttachmentCellRenderer.newRender(getDecorator(Attachment.class, null)), - IndividualObservationBatchTableModel.ATTACHMENT); - } - - // create obsTable model - IndividualObservationBatchTableModel tableModel = - new IndividualObservationBatchTableModel(individualObservationWeightUnit, - getModel(), -// defaultCaracteristic, -// getModel().getSexCaracteristic(), - columnModel); - - obsTable.setModel(tableModel); - obsTable.setColumnModel(columnModel); - - initTable(obsTable); - Color cellWithValueColor = getConfig().getColorCellWithValue(); - - Highlighter commentHighlighter = TuttiUIUtil.newBackgroundColorHighlighter( - new HighlightPredicate.AndHighlightPredicate( - new HighlightPredicate.IdentifierHighlightPredicate(IndividualObservationBatchTableModel.COMMENT), - // for not null value - (renderer, adapter) -> { - String value = (String) adapter.getValue(); - return StringUtils.isNotBlank(value); - }), cellWithValueColor); - obsTable.addHighlighter(commentHighlighter); - - installTableKeyListener(columnModel, obsTable, false); - - tableModel.addTableModelListener(e -> { - - int firstRow = e.getFirstRow(); - int lastRow = e.getLastRow(); - - switch (e.getType()) { - case TableModelEvent.DELETE: - if (tableModel.getRowCount() == 0) { - tableModel.addNewRow(); - - } else { - tableModel.recomputeRankOrders(firstRow); - } - break; - - case TableModelEvent.INSERT: - for (int i = firstRow; i <= lastRow; i++) { - IndividualObservationBatchRowModel newRow = tableModel.getRows().get(i); - newRow.addPropertyChangeListener(obsChangedListener); - - if (getModel().mustCopyIndividualObservationSize()) { - - getTableModel().incrementFrequencyRowsNumbers(newRow); - - } - - getModel().recomputeIndividualObservationRowValidState(newRow); - } - break; - - case TableModelEvent.UPDATE: - if (tableModel.getRowCount() == 0) { - tableModel.addNewRow(); - } - } - - getModel().recomputeCanEditLengthStep(); - }); - - obsTable.getSelectionModel().addListSelectionListener(e -> { - - if (!getModel().isInRafaleRowCreation()) { - resetSamplingLabel(); - } - - IndividualObservationBatchRowModel selectedRow = null; - - if (!obsTable.getSelectionModel().isSelectionEmpty()) { - if (obsTable.getSelectedRowCount() == 1) { - selectedRow = getObsTableModel().getEntry(obsTable.getSelectedRow()); - - } - } - - individualObservationUICache.updateSelectedRow(selectedRow); - }); - } +// protected void initObsTable() { +// +// JXTable obsTable = ui.getObsTable(); +// +// // can show / hide some columns in model +// obsTable.setColumnControlVisible(true); +// +// // create obsTable column model +// DefaultTableColumnModelExt columnModel = new DefaultTableColumnModelExt(); +// Decorator<Caracteristic> caracteristicDecorator = +// getDecorator(Caracteristic.class, DecoratorService.CARACTERISTIC_PARAMETER_ONLY_WITH_UNIT); +// Decorator<Caracteristic> caracteristicTipDecorator = +// getDecorator(Caracteristic.class, DecoratorService.CARACTERISTIC_WITH_UNIT); +// +// Decorator<CaracteristicQualitativeValue> caracteristicQualitativeDecorator = +// getDecorator(CaracteristicQualitativeValue.class, null); +// +// { +// // Rank column +// +// addIntegerColumnToModel(columnModel, +// IndividualObservationBatchTableModel.RANK, +// TuttiUI.INT_10_DIGITS_PATTERN, +// obsTable); +// +// } +// +// { // Size column +// +// addFloatColumnToModel(columnModel, +// IndividualObservationBatchTableModel.SIZE, +// TuttiUI.DECIMAL3_PATTERN, +// obsTable); +// } +// +// WeightUnit individualObservationWeightUnit = getConfig().getIndividualObservationWeightUnit(); +// +// { // Weight column +// +// addFloatColumnToModel(columnModel, +// IndividualObservationBatchTableModel.WEIGHT, +// individualObservationWeightUnit, +// obsTable); +// } +// +// List<Caracteristic> defaultCaracteristic = getModel().getDefaultCaracteristic(); +// +// for (Caracteristic caracteristic : defaultCaracteristic) { +// addCaracteristicColumnToModel(obsTable, +// columnModel, +// caracteristicDecorator, +// caracteristicTipDecorator, +// caracteristicQualitativeDecorator, +// caracteristic); +// } +// +// { // Other caracteristics column +// +// Set<Caracteristic> caracteristicsToSkip = Collections.unmodifiableSet( +// Sets.newHashSet(getModel().getDefaultCaracteristic())); +// +// addColumnToModel(columnModel, +// CaracteristicMapCellComponent.newEditor(ui, caracteristicsToSkip), +// CaracteristicMapCellComponent.newRender(getContext()), +// IndividualObservationBatchTableModel.OTHER_CARACTERISTICS); +// +// } +// +// { +// // Smapling code column +// +// addColumnToModel(columnModel, +// SamplingCodeCellEditor.newEditor(ui), +// SamplingCodeCellRenderer.newRender(), +// IndividualObservationBatchTableModel.SAMPLING_CODE); +// +// } +// +// { // Comment column +// +// addColumnToModel(columnModel, +// CommentCellEditor.newEditor(ui), +// CommentCellRenderer.newRender(), +// IndividualObservationBatchTableModel.COMMENT); +// +// } +// +// { // File column +// +// addColumnToModel(columnModel, +// AttachmentCellEditor.newEditor(ui), +// AttachmentCellRenderer.newRender(getDecorator(Attachment.class, null)), +// IndividualObservationBatchTableModel.ATTACHMENT); +// } +// +// // create obsTable model +// IndividualObservationBatchTableModel tableModel = +// new IndividualObservationBatchTableModel(individualObservationWeightUnit, +// getModel(), +//// defaultCaracteristic, +//// getModel().getSexCaracteristic(), +// columnModel); +// +// obsTable.setModel(tableModel); +// obsTable.setColumnModel(columnModel); +// +// initTable(obsTable); +// Color cellWithValueColor = getConfig().getColorCellWithValue(); +// +// Highlighter commentHighlighter = TuttiUIUtil.newBackgroundColorHighlighter( +// new HighlightPredicate.AndHighlightPredicate( +// new HighlightPredicate.IdentifierHighlightPredicate(IndividualObservationBatchTableModel.COMMENT), +// // for not null value +// (renderer, adapter) -> { +// String value = (String) adapter.getValue(); +// return StringUtils.isNotBlank(value); +// }), cellWithValueColor); +// obsTable.addHighlighter(commentHighlighter); +// +// installTableKeyListener(columnModel, obsTable, false); +// +// tableModel.addTableModelListener(e -> { +// +// int firstRow = e.getFirstRow(); +// int lastRow = e.getLastRow(); +// +// switch (e.getType()) { +// case TableModelEvent.DELETE: +// if (tableModel.getRowCount() == 0) { +// tableModel.addNewRow(); +// +// } else { +// tableModel.recomputeRankOrders(firstRow); +// } +// break; +// +// case TableModelEvent.INSERT: +// for (int i = firstRow; i <= lastRow; i++) { +// IndividualObservationBatchRowModel newRow = tableModel.getRows().get(i); +// newRow.addPropertyChangeListener(obsChangedListener); +// +// if (getModel().mustCopyIndividualObservationSize()) { +// +// getTableModel().incrementFrequencyRowsNumbers(newRow); +// +// } +// +// getModel().recomputeIndividualObservationRowValidState(newRow); +// } +// break; +// +// case TableModelEvent.UPDATE: +// if (tableModel.getRowCount() == 0) { +// tableModel.addNewRow(); +// } +// } +// +// getModel().recomputeCanEditLengthStep(); +// }); +// +// obsTable.getSelectionModel().addListSelectionListener(e -> { +// +// if (!getModel().isInRafaleRowCreation()) { +// resetSamplingLabel(); +// } +// +// IndividualObservationBatchRowModel selectedRow = null; +// +// if (!obsTable.getSelectionModel().isSelectionEmpty()) { +// if (obsTable.getSelectedRowCount() == 1) { +// selectedRow = getObsTableModel().getEntry(obsTable.getSelectedRow()); +// +// } +// } +// +// individualObservationUICache.updateSelectedRow(selectedRow); +// }); +// } +// public void resetSamplingLabel() { if (log.isDebugEnabled()) { @@ -1376,66 +1396,63 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci ui.getSamplingWarningLabel().setVisible(false); } - public void setMaturityCaracteristic(Caracteristic maturityCaracteristic) { - getModel().setMaturityCaracteristic(maturityCaracteristic); -// getObsTableModel().setMaturityCaracteristic(maturityCaracteristic); - if (maturityCaracteristic != null) { - addMaturityCaracteristicColumnToModel(maturityCaracteristic); - } - } - - protected void addMaturityCaracteristicColumnToModel(Caracteristic caracteristic) { - - Decorator<Caracteristic> caracteristicDecorator = - getDecorator(Caracteristic.class, DecoratorService.CARACTERISTIC_PARAMETER_ONLY_WITH_UNIT); - Decorator<Caracteristic> caracteristicTipDecorator = - getDecorator(Caracteristic.class, DecoratorService.CARACTERISTIC_WITH_UNIT); - - Decorator<CaracteristicQualitativeValue> caracteristicQualitativeDecorator = - getDecorator(CaracteristicQualitativeValue.class, null); - - // remove the row sorter while we add the new column - JXTable obsTable = ui.getObsTable(); - obsTable.setRowSorter(null); - obsTable.setAutoCreateRowSorter(false); - - TableColumnModelExt columnModel = (TableColumnModelExt) obsTable.getColumnModel(); - - maturityColumnId = addCaracteristicColumnToModel(obsTable, - columnModel, - caracteristicDecorator, - caracteristicTipDecorator, - caracteristicQualitativeDecorator, - caracteristic); - - Objects.requireNonNull(maturityColumnId); - - getObsTableModel().addMaturityIdentifier(maturityColumnId); - - // on cherche le bon index où insérer la colonne maturité (avant les autres caractéristiques, mais elle peut etre cachee) - int modelIndex = columnModel.getColumnExt(IndividualObservationBatchTableModel.OTHER_CARACTERISTICS).getModelIndex(); - int indexToMove = obsTable.convertColumnIndexToView(modelIndex); - - // si la colonne autres caracteristiques est cachée, alors on cherche la première colonne suivante non cachée - int columnCount = columnModel.getColumnCount(true); - while (indexToMove == -1 && modelIndex < columnCount) { - indexToMove = obsTable.convertColumnIndexToView(modelIndex); - modelIndex++; - } - // si une colonne après celle des autres caractéristiques est visible, on déplace la maturité avant cette colonne - // sinon, on laisse la maturité à la fin - if (modelIndex != -1) { - obsTable.moveColumn(columnModel.getColumnCount() - 1, indexToMove); - } - // reset the row sorter - obsTable.setAutoCreateRowSorter(true); - } +// public void setMaturityCaracteristic(Caracteristic maturityCaracteristic) { +// getModel().setMaturityCaracteristic(maturityCaracteristic); +//// getObsTableModel().setMaturityCaracteristic(maturityCaracteristic); +// if (maturityCaracteristic != null) { +// individualObservationBatchTableHandler.addMaturityCaracteristicColumnToModel(maturityCaracteristic); +// } +// } + +// protected void addMaturityCaracteristicColumnToModel(Caracteristic caracteristic) { +// +// Decorator<Caracteristic> caracteristicDecorator = +// getDecorator(Caracteristic.class, DecoratorService.CARACTERISTIC_PARAMETER_ONLY_WITH_UNIT); +// Decorator<Caracteristic> caracteristicTipDecorator = +// getDecorator(Caracteristic.class, DecoratorService.CARACTERISTIC_WITH_UNIT); +// +// Decorator<CaracteristicQualitativeValue> caracteristicQualitativeDecorator = +// getDecorator(CaracteristicQualitativeValue.class, null); +// +// // remove the row sorter while we add the new column +// JXTable obsTable = ui.getObsTable(); +// obsTable.setRowSorter(null); +// obsTable.setAutoCreateRowSorter(false); +// +// TableColumnModelExt columnModel = (TableColumnModelExt) obsTable.getColumnModel(); +// +// maturityColumnId = addCaracteristicColumnToModel(obsTable, +// columnModel, +// caracteristicDecorator, +// caracteristicTipDecorator, +// caracteristicQualitativeDecorator, +// caracteristic); +// +// Objects.requireNonNull(maturityColumnId); +// +// getObsTableModel().addMaturityIdentifier(maturityColumnId); +// +// // on cherche le bon index où insérer la colonne maturité (avant les autres caractéristiques, mais elle peut etre cachee) +// int modelIndex = columnModel.getColumnExt(IndividualObservationBatchTableModel.OTHER_CARACTERISTICS).getModelIndex(); +// int indexToMove = obsTable.convertColumnIndexToView(modelIndex); +// +// // si la colonne autres caracteristiques est cachée, alors on cherche la première colonne suivante non cachée +// int columnCount = columnModel.getColumnCount(true); +// while (indexToMove == -1 && modelIndex < columnCount) { +// indexToMove = obsTable.convertColumnIndexToView(modelIndex); +// modelIndex++; +// } +// // si une colonne après celle des autres caractéristiques est visible, on déplace la maturité avant cette colonne +// // sinon, on laisse la maturité à la fin +// if (modelIndex != -1) { +// obsTable.moveColumn(columnModel.getColumnCount() - 1, indexToMove); +// } +// // reset the row sorter +// obsTable.setAutoCreateRowSorter(true); +// } protected CaracteristicColumnIdentifier<IndividualObservationBatchRowModel> addCaracteristicColumnToModel(JXTable table, TableColumnModelExt columnModel, - Decorator<Caracteristic> caracteristicDecorator, - Decorator<Caracteristic> caracteristicTipDecorator, - Decorator<CaracteristicQualitativeValue> caracteristicQualitativeDecorator, Caracteristic caracteristic) { String header = caracteristicDecorator.toString(caracteristic); @@ -1533,8 +1550,7 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci SoundEngine soundEngine = getContext().getSoundEngine(); soundEngine.beepOnIchtyometerErrorReception(); - throw new ApplicationBusinessException( - t("tutti.editSpeciesFrequencies.error.itchyometer.bad.record", record.getRecord())); + throw new ApplicationBusinessException(t("tutti.editSpeciesFrequencies.error.itchyometer.bad.record", record.getRecord())); } } @@ -1609,9 +1625,9 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci ui.getLogsScrollPane().setVisible(logVisible); } - protected String getLabelWithUnit(String label, String unit) { - return label + " (" + unit + ")"; - } +// protected String getLabelWithUnit(String label, String unit) { +// return label + " (" + unit + ")"; +// } protected void reloadRowsFromIndividualObservations() { SpeciesFrequencyUIModel model = getModel(); @@ -1664,6 +1680,7 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci } model.reloadRows(); + } @Override @@ -1679,8 +1696,10 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci protected void beforeOpenPopup(int modelRowIndex, int modelColumnIndex) { super.beforeOpenPopup(modelRowIndex, modelColumnIndex); - boolean sampleCodeMenusEnabled = modelRowIndex >= 0 && ui.getObsTable().getSelectedRowCount() == 1 - && getObsTableModel().getRows().get(ui.getObsTable().getSelectedRow()).withSamplingCode(); + boolean sampleCodeMenusEnabled = individualObservationBatchTableHandler.isSampleCodeMenusEnabled(modelRowIndex); + +// boolean sampleCodeMenusEnabled = modelRowIndex >= 0 && ui.getObsTable().getSelectedRowCount() == 1 +// && getObsTableModel().getRows().get(ui.getObsTable().getSelectedRow()).withSamplingCode(); ui.getEditSampleCodeMenu().setEnabled(sampleCodeMenusEnabled); ui.getDeleteSampleCodeMenu().setEnabled(sampleCodeMenusEnabled); } @@ -1703,18 +1722,17 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci model.setTotalWeight(null); model.setSimpleCount(null); - Caracteristic lengthStepCaracteristic = null; - CopyIndividualObservationMode copyIndividualObservationMode = null; +// Caracteristic lengthStepCaracteristic = null; - List<SpeciesFrequencyRowModel> rows = new ArrayList<>(); - List<IndividualObservationBatchRowModel> obsRows = new ArrayList<>(); +// List<SpeciesFrequencyRowModel> rows = new ArrayList<>(); +// List<IndividualObservationBatchRowModel> obsRows = new ArrayList<>(); Species species = speciesBatch.getSpecies(); - IndividualObservationBatchTableModel obsTableModel = getObsTableModel(); - obsTableModel.setSpecies(species); +// IndividualObservationBatchTableModel obsTableModel = getObsTableModel(); +// obsTableModel.setSpecies(species); - SamplingCodePrefix samplingCodePrefix = new SamplingCodePrefix(getConfig().getSamplingCodePrefix(), decorate(species, DecoratorService.WITH_SURVEY_CODE_NO_NAME)); - obsTableModel.setSamplingCodePrefix(samplingCodePrefix); +// SamplingCodePrefix samplingCodePrefix = new SamplingCodePrefix(getConfig().getSamplingCodePrefix(), decorate(species, DecoratorService.WITH_SURVEY_CODE_NO_NAME)); +// obsTableModel.setSamplingCodePrefix(samplingCodePrefix); model.setTotalWeight(speciesBatch.getWeight()); @@ -1722,82 +1740,123 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci // try to load existing frequency // - if (CollectionUtils.isNotEmpty(frequency)) { - - SpeciesFrequencyTableModel tableModel = getTableModel(); - - for (SpeciesFrequencyRowModel rowModel : frequency) { - - SpeciesFrequencyRowModel newRow = tableModel.createNewRow(false, false); - newRow.copy(rowModel); - rows.add(newRow); - - } + List<SpeciesFrequencyRowModel> rows = getTableModel().loadRows(frequency); - // use first frequency row length step caracteristics + Caracteristic lengthStepCaracteristic = null; - SpeciesFrequencyRowModel rowModel = frequency.get(0); - lengthStepCaracteristic = rowModel.getLengthStepCaracteristic(); + if (!rows.isEmpty()) { + SpeciesFrequencyRowModel firstFrequencyRow = frequency.get(0); + lengthStepCaracteristic = firstFrequencyRow.getLengthStepCaracteristic(); if (log.isInfoEnabled()) { - log.info("Use existing lengthStep caracteristic / step " + decorate(lengthStepCaracteristic)); + log.info("Use existing lengthStep caracteristic / step from first existing frequency: " + decorate(lengthStepCaracteristic)); } + } +// if (CollectionUtils.isNotEmpty(frequency)) { +// +// SpeciesFrequencyTableModel tableModel = getTableModel(); +// +// for (SpeciesFrequencyRowModel rowModel : frequency) { +// +// SpeciesFrequencyRowModel newRow = tableModel.createNewRow(false, false); +// newRow.copy(rowModel); +// rows.add(newRow); +// +// } +// +// // use first frequency row length step caracteristics +// +// SpeciesFrequencyRowModel rowModel = frequency.get(0); +// lengthStepCaracteristic = rowModel.getLengthStepCaracteristic(); +// +// if (log.isInfoEnabled()) { +// log.info("Use existing lengthStep caracteristic / step " + decorate(lengthStepCaracteristic)); +// } +// } + // // try to load existing individual observations // - if (CollectionUtils.isNotEmpty(individualObservations)) { - - IndividualObservationBatchTableModel tableModel = getObsTableModel(); - tableModel.setRows(new ArrayList<>()); - - int rankOrder = 1; - for (IndividualObservationBatchRowModel rowModel : individualObservations) { - - CopyIndividualObservationMode incomingCopyIndividualObservationMode = rowModel.getCopyIndividualObservationMode(); - Objects.requireNonNull(incomingCopyIndividualObservationMode, "Mode de recopie non trouvé sur l'observation individuelle: " + rowModel.getId()); - if (copyIndividualObservationMode == null) { - copyIndividualObservationMode = incomingCopyIndividualObservationMode; - } else { - if (copyIndividualObservationMode != incomingCopyIndividualObservationMode) { - throw new IllegalStateException("Plusieurs modes de recopie trouvés sur les observations individuelles du lot, ce qui est impossible"); - } - } - IndividualObservationBatchRowModel newRow = tableModel.createNewRow(); - newRow.copy(rowModel); - newRow.setRankOrder(rankOrder++); - newRow.addPropertyChangeListener(obsChangedListener); - newRow.setValid(true); + List<IndividualObservationBatchRowModel> individualObservationRows = individualObservationBatchTableHandler.loadIndividualObservations(species, individualObservations); - model.moveMaturityValueFromCaracteristicsToDefaultCaracteristics(newRow); + CopyIndividualObservationMode copyIndividualObservationMode; + if (individualObservationRows.isEmpty()) { - obsRows.add(newRow); + copyIndividualObservationMode = CopyIndividualObservationMode.NOTHING; - } + } else { - // use first individual observation row length step caracteristics + IndividualObservationBatchRowModel firstIndividualObservationRow = individualObservationRows.get(0); + copyIndividualObservationMode = firstIndividualObservationRow.getCopyIndividualObservationMode(); if (lengthStepCaracteristic == null) { - IndividualObservationBatchRowModel rowModel = individualObservations.get(0); - lengthStepCaracteristic = rowModel.getLengthStepCaracteristic(); + + lengthStepCaracteristic = firstIndividualObservationRow.getLengthStepCaracteristic(); if (log.isInfoEnabled()) { - log.info("Use existing lengthStep caracteristic / step " + decorate(lengthStepCaracteristic)); + log.info("Use existing lengthStep caracteristic / step from first individual observation : " + decorate(lengthStepCaracteristic)); } - } - - } else { - // par défaut pas de mode de recopie - copyIndividualObservationMode = CopyIndividualObservationMode.NOTHING; + } } if (log.isInfoEnabled()) { log.info("CopyIndividualObservationMode: " + copyIndividualObservationMode); } +// if (CollectionUtils.isNotEmpty(individualObservations)) { +// +// IndividualObservationBatchTableModel tableModel = getObsTableModel(); +// tableModel.setRows(new ArrayList<>()); +// +// int rankOrder = 1; +// for (IndividualObservationBatchRowModel rowModel : individualObservations) { +// +// CopyIndividualObservationMode incomingCopyIndividualObservationMode = rowModel.getCopyIndividualObservationMode(); +// Objects.requireNonNull(incomingCopyIndividualObservationMode, "Mode de recopie non trouvé sur l'observation individuelle: " + rowModel.getId()); +// if (copyIndividualObservationMode == null) { +// copyIndividualObservationMode = incomingCopyIndividualObservationMode; +// } else { +// if (copyIndividualObservationMode != incomingCopyIndividualObservationMode) { +// throw new IllegalStateException("Plusieurs modes de recopie trouvés sur les observations individuelles du lot, ce qui est impossible"); +// } +// } +// IndividualObservationBatchRowModel newRow = tableModel.createNewRow(); +// newRow.copy(rowModel); +// newRow.setRankOrder(rankOrder++); +// newRow.addPropertyChangeListener(obsChangedListener); +// newRow.setValid(true); +// +// model.moveMaturityValueFromCaracteristicsToDefaultCaracteristics(newRow); +// +// obsRows.add(newRow); +// +// } +// +// // use first individual observation row length step caracteristics +// +// if (lengthStepCaracteristic == null) { +// IndividualObservationBatchRowModel rowModel = individualObservations.get(0); +// lengthStepCaracteristic = rowModel.getLengthStepCaracteristic(); +// +// if (log.isInfoEnabled()) { +// log.info("Use existing lengthStep caracteristic / step " + decorate(lengthStepCaracteristic)); +// } +// } +// +// } else { +// +// // par défaut pas de mode de recopie +// copyIndividualObservationMode = CopyIndividualObservationMode.NOTHING; +// +// } +// +// if (log.isInfoEnabled()) { +// log.info("CopyIndividualObservationMode: " + copyIndividualObservationMode); +// } SpeciesBatchRowModel previousSiblingRow = frequencyEditor.getPreviousSiblingRow(); @@ -1844,7 +1903,7 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci } if (log.isDebugEnabled()) { - log.debug("Will edit batch row: " + speciesBatch + " with " + rows.size() + " frequency"); + log.debug("Will edit batch row: " + speciesBatch + " with " + rows.size() + " frequencies and " + individualObservationRows.size() + " indivudual observations."); } Integer number = speciesBatch.getNumber(); @@ -1870,19 +1929,21 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci model.setLengthStepCaracteristic(lengthStepCaracteristic); model.setRows(rows); - CaracteristicMap sampleCategoryValues = new CaracteristicMap(); - Iterator<SampleCategory<?>> iterator = speciesBatch.iterator(); - iterator.forEachRemaining(sampleCategory -> { - Caracteristic caracteristic = sampleCategory.getCategoryDef().getCaracteristic(); - sampleCategoryValues.put(caracteristic, sampleCategory.getCategoryValue()); - }); + individualObservationBatchTableHandler.initCaracteristicValues(speciesBatch); - obsTableModel.setDefaultCaracteristicValues(sampleCategoryValues); - model.setNotEditableCaracteristic(sampleCategoryValues.keySet()); +// CaracteristicMap sampleCategoryValues = new CaracteristicMap(); +// Iterator<SampleCategory<?>> iterator = speciesBatch.iterator(); +// iterator.forEachRemaining(sampleCategory -> { +// Caracteristic caracteristic = sampleCategory.getCategoryDef().getCaracteristic(); +// sampleCategoryValues.put(caracteristic, sampleCategory.getCategoryValue()); +// }); +// +// obsTableModel.setDefaultCaracteristicValues(sampleCategoryValues); +// model.setNotEditableCaracteristic(sampleCategoryValues.keySet()); - model.setIndividualObservationRows(obsRows); - obsTableModel.setRows(obsRows); - model.recomputeIndividualObservationRowsValidateState(); + individualObservationBatchTableHandler.setIndividualObservationRows(individualObservationRows); +// obsTableModel.setRows(obsRows); +// model.recomputeIndividualObservationRowsValidateState(); // let's change the copy mode (mark it in init mode to avoid user change confirmation and some recompuations) model.setCopyIndividualObservationMode(null); @@ -1896,13 +1957,47 @@ public class SpeciesFrequencyUIHandler extends AbstractTuttiTableUIHandler<Speci } } - protected void removeMaturityColumnIfPresent() { - if (maturityColumnId != null) { - TableColumnExt maturityColumn = ui.getObsTable().getColumnExt(maturityColumnId); - ui.getObsTable().removeColumn(maturityColumn); - getObsTableModel().removeMaturityIdentifier(maturityColumnId); - maturityColumnId = null; - } +// protected void removeMaturityColumnIfPresent() { +// if (maturityColumnId != null) { +// TableColumnExt maturityColumn = ui.getObsTable().getColumnExt(maturityColumnId); +// ui.getObsTable().removeColumn(maturityColumn); +// getObsTableModel().removeMaturityIdentifier(maturityColumnId); +// maturityColumnId = null; +// } +// } + + + // Attention on surcharge les méthodes suivantes pour pouvoir les utiliser dans l'autre handler, ne rien changer (pour le moment)... + + @Override + protected <R> TableColumnExt addIntegerColumnToModel(TableColumnModel model, + ColumnIdentifier<R> identifier, + String numberPattern, + JTable table) { + return super.addIntegerColumnToModel(model, identifier, numberPattern, table); + } + + @Override + protected <R> TableColumnExt addFloatColumnToModel(TableColumnModel model, + ColumnIdentifier<R> identifier, + String numberPattern, + JTable table) { + return super.addFloatColumnToModel(model, identifier, numberPattern, table); + } + + @Override + protected <R> TableColumnExt addFloatColumnToModel(TableColumnModel model, ColumnIdentifier<R> identifier, WeightUnit weightUnit, JTable table) { + return super.addFloatColumnToModel(model, identifier, weightUnit, table); + } + + @Override + protected void installTableKeyListener(TableColumnModel columnModel, JTable table, boolean enterToChangeRow) { + super.installTableKeyListener(columnModel, table, enterToChangeRow); + } + + @Override + protected String decorate(Serializable object, String context) { + return super.decorate(object, context); } } diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyUIModel.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyUIModel.java index 0dc3fa4..2a20c53 100644 --- a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyUIModel.java +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/SpeciesFrequencyUIModel.java @@ -29,7 +29,6 @@ import fr.ifremer.tutti.persistence.entities.protocol.Rtp; import fr.ifremer.tutti.persistence.entities.referential.Caracteristic; import fr.ifremer.tutti.persistence.entities.referential.CaracteristicQualitativeValue; import fr.ifremer.tutti.type.WeightUnit; -import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.IndividualObservationBatchRowModel; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.SpeciesOrBenthosBatchUISupport; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.edit.SpeciesBatchRowModel; import fr.ifremer.tutti.ui.swing.util.computable.ComputableData; @@ -39,8 +38,6 @@ import fr.ifremer.tutti.util.Weights; import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.jfree.data.xy.XYSeries; -import org.jfree.data.xy.XYSeriesCollection; import java.beans.PropertyChangeEvent; import java.beans.PropertyChangeListener; @@ -272,19 +269,19 @@ public class SpeciesFrequencyUIModel extends AbstractTuttiTableUIModel<SpeciesBa */ protected CopyIndividualObservationMode copyIndividualObservationMode = CopyIndividualObservationMode.NOTHING; - /** - * To store frequencies graph series. - * - * @since 3.11 - */ - protected final XYSeriesCollection frequenciesDataset; +// /** +// * To store frequencies graph series. +// * +// * @since 3.11 +// */ +// protected final XYSeriesCollection frequenciesDataset; - /** - * To store average weights graph series. - * - * @since 4.5 - */ - protected final XYSeriesCollection averageWeightsDataset; +// /** +// * To store average weights graph series. +// * +// * @since 4.5 +// */ +// protected final XYSeriesCollection averageWeightsDataset; /** * Default caracteristics coming from protocol. @@ -338,6 +335,9 @@ public class SpeciesFrequencyUIModel extends AbstractTuttiTableUIModel<SpeciesBa */ protected Caracteristic maturityCaracteristic; + protected final AverageWeightsHistogramModel averageWeightsHistogramModel; + protected final FrequenciesHistogramModel frequenciesHistogramModel; + protected final PropertyChangeListener rowInErrorChangedListener = new PropertyChangeListener() { @Override @@ -360,25 +360,34 @@ public class SpeciesFrequencyUIModel extends AbstractTuttiTableUIModel<SpeciesBa this.totalComputedOrNotWeight.addPropagateListener(PROPERTY_TOTAL_WEIGHT, this); setEmptyRows(new HashSet<>()); - XYSeries series = new XYSeries("", true, false); - - frequenciesDataset = new XYSeriesCollection(series); - frequenciesDataset.setIntervalPositionFactor(0); - frequenciesDataset.setIntervalWidth(0); + this.averageWeightsHistogramModel = new AverageWeightsHistogramModel(weightUnit, individualObservationWeightUnit); + this.frequenciesHistogramModel = new FrequenciesHistogramModel(weightUnit, individualObservationWeightUnit); - series = new XYSeries("", true, false); +// XYSeries series = new XYSeries("", true, false); +// +// frequenciesDataset = new XYSeriesCollection(series); +// frequenciesDataset.setIntervalPositionFactor(0); +// frequenciesDataset.setIntervalWidth(0); - averageWeightsDataset = new XYSeriesCollection(series); - averageWeightsDataset.setIntervalPositionFactor(0); - averageWeightsDataset.setIntervalWidth(0); +// series = new XYSeries("", true, false); +// +// averageWeightsDataset = new XYSeriesCollection(series); +// averageWeightsDataset.setIntervalPositionFactor(0); +// averageWeightsDataset.setIntervalWidth(0); - this.defaultCaracteristic = defaultCaracteristic == null - ? new ArrayList<>() - : new ArrayList<>(defaultCaracteristic); + this.defaultCaracteristic = defaultCaracteristic == null ? new ArrayList<>() : new ArrayList<>(defaultCaracteristic); setIndividualObservationRowsInError(new HashSet<>()); } + public AverageWeightsHistogramModel getAverageWeightsHistogramModel() { + return averageWeightsHistogramModel; + } + + public FrequenciesHistogramModel getFrequenciesHistogramModel() { + return frequenciesHistogramModel; + } + public WeightUnit getWeightUnit() { return weightUnit; } @@ -397,30 +406,34 @@ public class SpeciesFrequencyUIModel extends AbstractTuttiTableUIModel<SpeciesBa setEmptyRows(new HashSet<>()); - XYSeries frequenciesSeries = frequenciesDataset.getSeries(0); - frequenciesSeries.clear(); - XYSeries averageWeightsSeries = averageWeightsDataset.getSeries(0); - averageWeightsSeries.clear(); +// XYSeries frequenciesSeries = frequenciesDataset.getSeries(0); +// frequenciesSeries.clear(); +// XYSeries averageWeightsSeries = averageWeightsDataset.getSeries(0); +// averageWeightsSeries.clear(); cache.loadCache(rows); recomputeRowsValidateState(); - if (rows != null) { - - rows.stream().filter(SpeciesFrequencyRowModel::isValid).forEach(row -> { + //FIXME Je préfèrerais ne pas pusher, ... + frequenciesHistogramModel.reloadRows(rows); + averageWeightsHistogramModel.reloadRows(rows); - Float lengthStep = row.getLengthStep(); - Integer number = row.getNumber(); +// if (rows != null) { +// +// rows.stream().filter(SpeciesFrequencyRowModel::isValid).forEach(row -> { +// +// Float lengthStep = row.getLengthStep(); +// Integer number = row.getNumber(); - frequenciesSeries.addOrUpdate(lengthStep, number); +// frequenciesSeries.addOrUpdate(lengthStep, number); - Float averageWeight = Weights.convert(weightUnit, individualObservationWeightUnit, row.computeAverageWeight()); - if (averageWeight != null) { - averageWeightsSeries.addOrUpdate(lengthStep, averageWeight); - } - }); - } +// Float averageWeight = Weights.convert(weightUnit, individualObservationWeightUnit, row.computeAverageWeight()); +// if (averageWeight != null) { +// averageWeightsSeries.addOrUpdate(lengthStep, averageWeight); +// } +// }); +// } recomputeTotalNumberAndWeight(); @@ -1024,10 +1037,10 @@ public class SpeciesFrequencyUIModel extends AbstractTuttiTableUIModel<SpeciesBa && row.getWeight() != null; } - public void setDataSetIntervalWidth(float step) { - frequenciesDataset.setIntervalWidth(step); - averageWeightsDataset.setIntervalWidth(step); - } +// public void setDataSetIntervalWidth(float step) { +// frequenciesDataset.setIntervalWidth(step); +// averageWeightsDataset.setIntervalWidth(step); +// } public List<Caracteristic> getDefaultCaracteristic() { return defaultCaracteristic; diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/ApplySpeciesFrequencyRafaleAction.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/ApplySpeciesFrequencyRafaleAction.java index d560dab..02ab245 100644 --- a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/ApplySpeciesFrequencyRafaleAction.java +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/ApplySpeciesFrequencyRafaleAction.java @@ -24,8 +24,8 @@ package fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.ac * #L% */ -import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.IndividualObservationBatchRowModel; -import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.IndividualObservationBatchTableModel; +import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.IndividualObservationBatchRowModel; +import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.IndividualObservationBatchTableModel; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.SpeciesFrequencyLogRowModel; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.SpeciesFrequencyLogsTableModel; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.SpeciesFrequencyRowModel; diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/DeleteSampleCodeAction.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/DeleteSampleCodeAction.java index c6f6fc8..252f883 100644 --- a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/DeleteSampleCodeAction.java +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/DeleteSampleCodeAction.java @@ -24,8 +24,8 @@ package fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.ac * #L% */ -import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.IndividualObservationBatchRowModel; -import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.IndividualObservationBatchTableModel; +import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.IndividualObservationBatchRowModel; +import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.IndividualObservationBatchTableModel; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.SpeciesFrequencyUI; import fr.ifremer.tutti.ui.swing.util.actions.SimpleActionSupport; import org.jdesktop.swingx.JXTable; diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/DeleteSpeciesFrequencyLogRowAction.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/DeleteSpeciesFrequencyLogRowAction.java index 1aee35c..d257ccd 100644 --- a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/DeleteSpeciesFrequencyLogRowAction.java +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/DeleteSpeciesFrequencyLogRowAction.java @@ -24,7 +24,7 @@ package fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.ac * #L% */ -import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.IndividualObservationBatchTableModel; +import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.IndividualObservationBatchTableModel; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.SpeciesFrequencyLogCellComponent; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.SpeciesFrequencyLogRowModel; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.SpeciesFrequencyLogsTableModel; diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/EditSampleCodeAction.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/EditSampleCodeAction.java index 91ff95a..8e6fba3 100644 --- a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/EditSampleCodeAction.java +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/EditSampleCodeAction.java @@ -26,8 +26,8 @@ package fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.ac import fr.ifremer.tutti.service.PersistenceService; import fr.ifremer.tutti.ui.swing.TuttiUIContext; -import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.IndividualObservationBatchRowModel; -import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.IndividualObservationBatchTableModel; +import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.IndividualObservationBatchRowModel; +import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.IndividualObservationBatchTableModel; import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.SampleCodeEditionPopupUI; import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.SampleCodeEditionPopupUIModel; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.IndividualObservationUICache; diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/ImportMultiPostSpeciesSupportAction.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/ImportMultiPostSpeciesSupportAction.java index f608cff..e20afe6 100644 --- a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/ImportMultiPostSpeciesSupportAction.java +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/ImportMultiPostSpeciesSupportAction.java @@ -27,7 +27,7 @@ import fr.ifremer.tutti.persistence.entities.data.IndividualObservationBatch; import fr.ifremer.tutti.persistence.entities.data.SpeciesBatch; import fr.ifremer.tutti.persistence.entities.data.SpeciesBatchFrequency; import fr.ifremer.tutti.service.catches.multipost.MultiPostImportResult; -import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.IndividualObservationBatchRowModel; +import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.IndividualObservationBatchRowModel; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.SpeciesOrBenthosBatchUISupport; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.edit.SpeciesBatchRowModel; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.SpeciesFrequencyCellComponent; diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/RemoveObservationAction.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/RemoveObservationAction.java index 6517d51..0ab0c09 100644 --- a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/RemoveObservationAction.java +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/content/operation/catches/species/frequency/actions/RemoveObservationAction.java @@ -24,8 +24,8 @@ package fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.ac * #L% */ -import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.IndividualObservationBatchRowModel; -import fr.ifremer.tutti.ui.swing.content.operation.catches.individualobservation.IndividualObservationBatchTableModel; +import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.IndividualObservationBatchRowModel; +import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.IndividualObservationBatchTableModel; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.IndividualObservationUICache; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.SpeciesFrequencyUI; import fr.ifremer.tutti.ui.swing.content.operation.catches.species.frequency.SpeciesFrequencyUIHandler; -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.