branch feature/8245 created (now 278f703)
This is an automated email from the git hooks/post-receive script. New change to branch feature/8245 in repository tutti. See https://gitlab.nuiton.org/codelutin/tutti.git at 278f703 En avant la musique... création de modèles et controleurs... This branch includes the following new commits: new 1d6b0ed Mauvais flow, c'est pas faute de l'avoir dit pleins de fois... new 1a78521 Ajout d'une classe pour gérer les unités new 138580c Correction de l'apgorithme de comparaision de poids new 278f703 En avant la musique... création de modèles et controleurs... The 4 revisions listed above as "new" are entirely new to this repository and will be described in separate emails. The revisions listed as "adds" were already present in the repository and have only been added to this reference. Detailed log of new commits: 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... commit 138580c9b2f7462a3f4f22f15802586ab8e2026b Author: Tony CHEMIT <chemit@codelutin.com> Date: Fri Apr 15 09:46:35 2016 +0200 Correction de l'apgorithme de comparaision de poids commit 1a78521fce03c26f899a8c3bbb68eb8602864070 Author: Tony CHEMIT <chemit@codelutin.com> Date: Fri Apr 15 09:46:20 2016 +0200 Ajout d'une classe pour gérer les unités commit 1d6b0ed3ab81dbf4b22e88500ee709cdece07d80 Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Apr 14 17:33:49 2016 +0200 Mauvais flow, c'est pas faute de l'avoir dit pleins de fois... -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.
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 1d6b0ed3ab81dbf4b22e88500ee709cdece07d80 Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Apr 14 17:33:49 2016 +0200 Mauvais flow, c'est pas faute de l'avoir dit pleins de fois... --- .../frequency/actions/ApplySpeciesFrequencyRafaleAction.java | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) 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 299af42..d560dab 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 @@ -79,8 +79,6 @@ public class ApplySpeciesFrequencyRafaleAction { float aroundLengthStep = model.getLengthStep(step); - model.setInRafaleRowCreation(true); - if (model.isCopyIndividualObservationNothing()) { SpeciesFrequencyTableModel tableModel = handler.getTableModel(); @@ -147,8 +145,14 @@ public class ApplySpeciesFrequencyRafaleAction { int rowIndex = obsTableModel.getRowIndex(obsRow); SwingUtilities.invokeLater(() -> { - selectRow(ui.getObsTable(), rowIndex); - model.setInRafaleRowCreation(false); + + model.setInRafaleRowCreation(true); + try { + selectRow(ui.getObsTable(), rowIndex); + } finally { + model.setInRafaleRowCreation(false); + } + }); } -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.
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 1a78521fce03c26f899a8c3bbb68eb8602864070 Author: Tony CHEMIT <chemit@codelutin.com> Date: Fri Apr 15 09:46:20 2016 +0200 Ajout d'une classe pour gérer les unités --- .../src/main/java/fr/ifremer/tutti/util/Units.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/util/Units.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/util/Units.java new file mode 100644 index 0000000..e2c8839 --- /dev/null +++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/util/Units.java @@ -0,0 +1,13 @@ +package fr.ifremer.tutti.util; + +/** + * Created on 15/04/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class Units { + + public static String getLabelWithUnit(String label, String unit) { + return label + " (" + unit + ")"; + } +} -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.
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 138580c9b2f7462a3f4f22f15802586ab8e2026b Author: Tony CHEMIT <chemit@codelutin.com> Date: Fri Apr 15 09:46:35 2016 +0200 Correction de l'apgorithme de comparaision de poids --- .../src/main/java/fr/ifremer/tutti/type/WeightUnit.java | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/type/WeightUnit.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/type/WeightUnit.java index 39cd373..a2d309c 100644 --- a/tutti-persistence/src/main/java/fr/ifremer/tutti/type/WeightUnit.java +++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/type/WeightUnit.java @@ -100,7 +100,7 @@ public enum WeightUnit implements Comparator<Float> { Objects.requireNonNull(v0, "can not compare null weights"); Objects.requireNonNull(v1, "can not compare null weights"); - float delta = round(v0) - round(v1); + float delta = roundWithSign(v0) - roundWithSign(v1); int result; if (delta > rawPrecision) { // v0 > v1 @@ -173,6 +173,19 @@ public enum WeightUnit implements Comparator<Float> { return result; } + public Float roundWithSign(Float weight) { + Float result; + if (weight == null) { + result = null; + } else { + + BigDecimal sumB = new BigDecimal(String.valueOf(weight)) + .setScale(numberDigits, BigDecimal.ROUND_HALF_UP); + result = sumB.floatValue(); + } + return result; + } + public String decorateLabel(String label) { return String.format("%s (%s)", label, getShortLabel()); } -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.
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>.
participants (1)
-
codelutin.com scm