This is an automated email from the git hooks/post-receive script. New commit to branch develop in repository observe. See http://git.codelutin.com/observe.git commit e387f565f15ccb20d67f33a5cabb37670220684d Author: Tony CHEMIT <chemit@codelutin.com> Date: Tue Apr 7 18:00:56 2015 +0200 refs#6855 edition des caracteristics d'un equipeemnt --- .../src/main/java/fr/ird/observe/DataService.java | 27 ++ .../referentiel/GearCaracteristicTypes.java | 61 +++ .../src/main/xmi/observe-seine.properties | 1 + observe-entities/src/main/xmi/observe-seine.zargo | Bin 85926 -> 85905 bytes .../seine/GearUseFeatureMeasurementCellEditor.java | 123 ++++++ .../GearUseFeatureMeasurementCellRenderer.java | 91 +++++ ...GearUseFeaturesMeasurementSeinesTableModel.java | 102 +++++ .../impl/seine/GearUseFeaturesSeineTableModel.java | 94 +++++ .../table/impl/seine/GearUseFeaturesSeineUI.css | 30 ++ .../table/impl/seine/GearUseFeaturesSeineUI.jaxx | 95 +++-- .../impl/seine/GearUseFeaturesSeineUIHandler.java | 413 +++++++++++++++++---- .../impl/seine/GearUseFeaturesSeineUIModel.java | 71 ++-- .../resources/i18n/observe-swing_en_GB.properties | 8 + .../resources/i18n/observe-swing_es_ES.properties | 8 + .../resources/i18n/observe-swing_fr_FR.properties | 10 +- 15 files changed, 1003 insertions(+), 131 deletions(-) diff --git a/observe-business/src/main/java/fr/ird/observe/DataService.java b/observe-business/src/main/java/fr/ird/observe/DataService.java index 806f8b0..b86d44c 100644 --- a/observe-business/src/main/java/fr/ird/observe/DataService.java +++ b/observe-business/src/main/java/fr/ird/observe/DataService.java @@ -65,6 +65,9 @@ import fr.ird.observe.entities.referentiel.SpeciesListDAO; import fr.ird.observe.entities.referentiel.longline.SensorType; import fr.ird.observe.entities.seine.ActivitySeine; import fr.ird.observe.entities.seine.ActivitySeines; +import fr.ird.observe.entities.seine.GearUseFeaturesMeasurementSeine; +import fr.ird.observe.entities.seine.GearUseFeaturesMeasurementSeineImpl; +import fr.ird.observe.entities.seine.GearUseFeaturesSeine; import fr.ird.observe.entities.seine.NonTargetCatch; import fr.ird.observe.entities.seine.NonTargetLength; import fr.ird.observe.entities.seine.NonTargetSample; @@ -1354,6 +1357,30 @@ public class DataService { } } + public List<GearUseFeaturesMeasurementSeine> getGearUseFeaturesMeasurementSeine(DataSource source, GearUseFeaturesSeine bean, final TopiaEntityBinder<GearUseFeaturesMeasurementSeine> binder) throws DataSourceException { + + String txName = "getGearUseFeaturesMeasurementSeine : " + bean.getTopiaId(); + TopiaContext tx = beginTransaction(source, txName); + try { + TopiaDAO<GearUseFeaturesSeine> dao = source.getDAO(tx, GearUseFeaturesSeine.class); + GearUseFeaturesSeine gearUseFeaturesSeine = dao.findByTopiaId(bean.getTopiaId()); + List<GearUseFeaturesMeasurementSeine> result = new ArrayList<GearUseFeaturesMeasurementSeine>(); + for (GearUseFeaturesMeasurementSeine measurementSource : gearUseFeaturesSeine.getGearUseFeaturesMeasurement()) { + GearUseFeaturesMeasurementSeine target = new GearUseFeaturesMeasurementSeineImpl(); + measurementSource.getGearCaracteristic().getGearCaracteristicType(); + binder.load(measurementSource, target, true); + result.add(target); + } + return result; + + } catch (TopiaException e) { + throw new DataSourceException(e, txName); + } finally { + closeTransaction(source, tx, txName); + } + } + + public <E extends TopiaEntity> List<String> getEntityIds(DataSource source, Class<E> refClass) throws DataSourceException { diff --git a/observe-entities/src/main/java/fr/ird/observe/entities/referentiel/GearCaracteristicTypes.java b/observe-entities/src/main/java/fr/ird/observe/entities/referentiel/GearCaracteristicTypes.java new file mode 100644 index 0000000..409e776 --- /dev/null +++ b/observe-entities/src/main/java/fr/ird/observe/entities/referentiel/GearCaracteristicTypes.java @@ -0,0 +1,61 @@ +package fr.ird.observe.entities.referentiel; + +import com.google.common.collect.Sets; + +import java.util.Set; + +/** + * Created on 4/7/15. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 3.16 + */ +public class GearCaracteristicTypes { + + public static final Set<String> INTEGER_IDS = Sets.newHashSet( + "fr.ird.observe.entities.referentiel.GearCaracteristicType#1239832686123#0.3", + "fr.ird.observe.entities.referentiel.GearCaracteristicType#1239832686123#0.5" + ); + + public static final Set<String> FLOAT_IDS = Sets.newHashSet( + "fr.ird.observe.entities.referentiel.GearCaracteristicType#1239832686123#0.4", + "fr.ird.observe.entities.referentiel.GearCaracteristicType#1239832686123#0.6" + ); + + + public static boolean isBoolean(GearCaracteristicType type) { + return "fr.ird.observe.entities.referentiel.GearCaracteristicType#1239832686123#0.2".equals(type.getTopiaId()); + } + + public static boolean isInteger(GearCaracteristicType type) { + return INTEGER_IDS.contains(type.getTopiaId()); + } + + public static boolean isFloat(GearCaracteristicType type) { + return FLOAT_IDS.contains(type.getTopiaId()); + } + + public static Object getTypeValue(GearCaracteristicType type, Object value) { + + if (value != null) { + + if (isBoolean(type)) { + + value = Boolean.valueOf((String) value); + + } else if (isInteger(type)) { + + value = Float.valueOf((String) value).intValue(); + + } else if (isFloat(type)) { + + value = Float.valueOf((String) value); + + } + } + + return value; + + } + +} diff --git a/observe-entities/src/main/xmi/observe-seine.properties b/observe-entities/src/main/xmi/observe-seine.properties index 021e5ab..47316c7 100644 --- a/observe-entities/src/main/xmi/observe-seine.properties +++ b/observe-entities/src/main/xmi/observe-seine.properties @@ -102,6 +102,7 @@ fr.ird.observe.entities.seine.SetSeine.attribute.startTime.tagvalue.type=time fr.ird.observe.entities.seine.NonTargetLength.attribute.sex.tagvalue.lazy=false fr.ird.observe.entities.referentiel.seine.WeightCategory.attribute.species.tagvalue.lazy=false +fr.ird.observe.entities.referentiel.GearCaracteristic.attribute.gearCaracteristicType.tagvalue.lazy=false ############################################################################### ### Natural Ids ############################################################### diff --git a/observe-entities/src/main/xmi/observe-seine.zargo b/observe-entities/src/main/xmi/observe-seine.zargo index 2320287..ef9f846 100644 Binary files a/observe-entities/src/main/xmi/observe-seine.zargo and b/observe-entities/src/main/xmi/observe-seine.zargo differ diff --git a/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeatureMeasurementCellEditor.java b/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeatureMeasurementCellEditor.java new file mode 100644 index 0000000..f749490 --- /dev/null +++ b/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeatureMeasurementCellEditor.java @@ -0,0 +1,123 @@ +package fr.ird.observe.ui.content.table.impl.seine; + +import fr.ird.observe.entities.referentiel.GearCaracteristic; +import fr.ird.observe.entities.referentiel.GearCaracteristicType; +import fr.ird.observe.entities.referentiel.GearCaracteristicTypes; +import jaxx.runtime.swing.JAXXWidgetUtil; +import jaxx.runtime.swing.editor.cell.NumberCellEditor; + +import javax.swing.AbstractCellEditor; +import javax.swing.JTable; +import javax.swing.border.LineBorder; +import javax.swing.table.TableCellEditor; +import java.awt.Color; +import java.awt.Component; +import java.util.Map; +import java.util.TreeMap; + +/** + * Created on 4/7/15. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 3.16 + */ +public class GearUseFeatureMeasurementCellEditor extends AbstractCellEditor implements TableCellEditor { + + private static final long serialVersionUID = 1L; + + protected int caracteristicColumn; + + protected TableCellEditor editor; + + protected Map<String, TableCellEditor> editorsByGearCaracteristicId; + + + public GearUseFeatureMeasurementCellEditor(int caracteristicColumn) { + super(); + this.caracteristicColumn = caracteristicColumn; + + } + + @Override + public Object getCellEditorValue() { + return editor.getCellEditorValue(); + } + + public Map<String, TableCellEditor> getEditorsByGearCaracteristicId(JTable table) { + if (editorsByGearCaracteristicId == null) { + editorsByGearCaracteristicId = new TreeMap<String, TableCellEditor>(); + + { + // texte + TableCellEditor editor = table.getDefaultEditor(Object.class); + editorsByGearCaracteristicId.put("fr.ird.observe.entities.referentiel.GearCaracteristicType#1239832686123#0.1", editor); + } + { + // boolean + TableCellEditor editor = table.getDefaultEditor(Boolean.class); + editorsByGearCaracteristicId.put("fr.ird.observe.entities.referentiel.GearCaracteristicType#1239832686123#0.2", editor); + } + { + // entier signé + NumberCellEditor<Integer> editor = JAXXWidgetUtil.newNumberTableCellEditor(Integer.class, true); + editor.getNumberEditor().setSelectAllTextOnError(true); + editor.getNumberEditor().setNumberPattern("\\d{0,6}?"); + editor.getNumberEditor().getTextField().setBorder(new LineBorder(Color.GRAY, 2)); + editorsByGearCaracteristicId.put("fr.ird.observe.entities.referentiel.GearCaracteristicType#1239832686123#0.3", editor); + } + { + // décimal signé + NumberCellEditor<Float> editor = JAXXWidgetUtil.newNumberTableCellEditor(Float.class, true); + editor.getNumberEditor().setSelectAllTextOnError(true); + editor.getNumberEditor().setNumberPattern("\\d{0,6}(\\.\\d{0,4})?"); + editor.getNumberEditor().getTextField().setBorder(new LineBorder(Color.GRAY, 2)); + editorsByGearCaracteristicId.put("fr.ird.observe.entities.referentiel.GearCaracteristicType#1239832686123#0.4", editor); + } + { + // entier non signé + NumberCellEditor<Integer> editor = JAXXWidgetUtil.newNumberTableCellEditor(Integer.class, false); + editor.getNumberEditor().setSelectAllTextOnError(true); + editor.getNumberEditor().setNumberPattern("\\d{0,6}?"); + editor.getNumberEditor().getTextField().setBorder(new LineBorder(Color.GRAY, 2)); + editorsByGearCaracteristicId.put("fr.ird.observe.entities.referentiel.GearCaracteristicType#1239832686123#0.5", editor); + } + { + // décimal non signé + NumberCellEditor<Float> editor = JAXXWidgetUtil.newNumberTableCellEditor(Float.class, false); + editor.getNumberEditor().setSelectAllTextOnError(true); + editor.getNumberEditor().setNumberPattern("\\d{0,6}(\\.\\d{0,4})?"); + editor.getNumberEditor().getTextField().setBorder(new LineBorder(Color.GRAY, 2)); + editorsByGearCaracteristicId.put("fr.ird.observe.entities.referentiel.GearCaracteristicType#1239832686123#0.6", editor); + } + + } + return editorsByGearCaracteristicId; + } + + @Override + public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) { + + GearCaracteristic caracteristic = (GearCaracteristic) table.getModel().getValueAt(row, caracteristicColumn); + if (caracteristic == null) { + + // can't edit a null value ? + editor = table.getDefaultEditor(Object.class); + + } else { + GearCaracteristicType gearCaracteristicType = caracteristic.getGearCaracteristicType(); + + String gearCaracteristicTypeId = gearCaracteristicType.getTopiaId(); + + Map<String, TableCellEditor> editors = getEditorsByGearCaracteristicId(table); + editor = editors.get(gearCaracteristicTypeId); + + value = GearCaracteristicTypes.getTypeValue(gearCaracteristicType, value); + + } + + Component result = editor.getTableCellEditorComponent(table, value, isSelected, row, column); + return result; + + } + +} diff --git a/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeatureMeasurementCellRenderer.java b/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeatureMeasurementCellRenderer.java new file mode 100644 index 0000000..56e130f --- /dev/null +++ b/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeatureMeasurementCellRenderer.java @@ -0,0 +1,91 @@ +package fr.ird.observe.ui.content.table.impl.seine; + +import fr.ird.observe.entities.referentiel.GearCaracteristic; +import fr.ird.observe.entities.referentiel.GearCaracteristicType; +import fr.ird.observe.entities.referentiel.GearCaracteristicTypes; +import fr.ird.observe.ui.UIHelper; + +import javax.swing.JTable; +import javax.swing.table.DefaultTableCellRenderer; +import javax.swing.table.TableCellRenderer; +import java.awt.Component; +import java.util.Map; +import java.util.TreeMap; + +/** + * Created on 4/7/15. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 3.16 + */ +public class GearUseFeatureMeasurementCellRenderer implements TableCellRenderer { + + protected final int caracteristicColumn; + + protected final Map<String, TableCellRenderer> renderersByCaracteristicTypeId; + + + public GearUseFeatureMeasurementCellRenderer(int caracteristicColumn, DefaultTableCellRenderer renderer) { + + this.caracteristicColumn = caracteristicColumn; + renderersByCaracteristicTypeId = new TreeMap<String, TableCellRenderer>(); + + { + // texte + TableCellRenderer editor = UIHelper.newStringTableCellRenderer(renderer, 10, true); + renderersByCaracteristicTypeId.put("fr.ird.observe.entities.referentiel.GearCaracteristicType#1239832686123#0.1", editor); + } + { + // boolean + TableCellRenderer editor = UIHelper.newBooleanTableCellRenderer(renderer); + renderersByCaracteristicTypeId.put("fr.ird.observe.entities.referentiel.GearCaracteristicType#1239832686123#0.2", editor); + } + { + // entier signé + TableCellRenderer editor = UIHelper.newEmptyNumberTableCellRenderer(renderer); + renderersByCaracteristicTypeId.put("fr.ird.observe.entities.referentiel.GearCaracteristicType#1239832686123#0.3", editor); + } + { + // décimal signé + TableCellRenderer editor = UIHelper.newEmptyNumberTableCellRenderer(renderer); + renderersByCaracteristicTypeId.put("fr.ird.observe.entities.referentiel.GearCaracteristicType#1239832686123#0.4", editor); + } + { + // entier non signé + TableCellRenderer editor = UIHelper.newEmptyNumberTableCellRenderer(renderer); + renderersByCaracteristicTypeId.put("fr.ird.observe.entities.referentiel.GearCaracteristicType#1239832686123#0.5", editor); + } + { + // décimal non signé + TableCellRenderer editor = UIHelper.newEmptyNumberTableCellRenderer(renderer); + renderersByCaracteristicTypeId.put("fr.ird.observe.entities.referentiel.GearCaracteristicType#1239832686123#0.6", editor); + } + } + + @Override + public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) { + + TableCellRenderer tableCellRenderer; + + GearCaracteristic caracteristic = (GearCaracteristic) table.getModel().getValueAt(row, caracteristicColumn); + if (caracteristic == null) { + + tableCellRenderer = table.getDefaultRenderer(Object.class); + + } else { + GearCaracteristicType gearCaracteristicType = caracteristic.getGearCaracteristicType(); + + String gearCaracteristicTypeId = gearCaracteristicType.getTopiaId(); + + tableCellRenderer = renderersByCaracteristicTypeId.get(gearCaracteristicTypeId); + + value = GearCaracteristicTypes.getTypeValue(gearCaracteristicType, value); + + } + + Component result = tableCellRenderer.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column); + return result; + + } + +} diff --git a/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeaturesMeasurementSeinesTableModel.java b/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeaturesMeasurementSeinesTableModel.java new file mode 100644 index 0000000..d459f2f --- /dev/null +++ b/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeaturesMeasurementSeinesTableModel.java @@ -0,0 +1,102 @@ +package fr.ird.observe.ui.content.table.impl.seine; + +import fr.ird.observe.entities.referentiel.GearCaracteristic; +import fr.ird.observe.entities.seine.GearUseFeaturesMeasurementSeine; +import fr.ird.observe.entities.seine.GearUseFeaturesMeasurementSeineImpl; +import fr.ird.observe.ui.util.table.EditableTableWithCacheTableModelSupport; +import org.nuiton.topia.persistence.util.TopiaEntityBinder; + +/** + * Created on 4/7/15. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 3.16 + */ +public class GearUseFeaturesMeasurementSeinesTableModel extends EditableTableWithCacheTableModelSupport<GearUseFeaturesMeasurementSeine> { + + private static final long serialVersionUID = 1L; + + public GearUseFeaturesMeasurementSeinesTableModel(TopiaEntityBinder<GearUseFeaturesMeasurementSeine> topiaBinder) { + super(topiaBinder); + } + + @Override + public boolean isRowNotEmpty(GearUseFeaturesMeasurementSeine valid) { + return !(valid.getGearCaracteristic() == null && valid.getMeasurementValue() == null); + } + + @Override + protected boolean isRowValid(GearUseFeaturesMeasurementSeine valid) { + String size = valid.getMeasurementValue(); + return !(valid.getGearCaracteristic() == null || size == null) && !size.isEmpty(); + } + + @Override + public int getColumnCount() { + return 2; + } + + @Override + public Object getValueAt(int rowIndex, int columnIndex) { + + GearUseFeaturesMeasurementSeine measure = data.get(rowIndex); + Object result; + switch (columnIndex) { + case 0: + result = measure.getGearCaracteristic(); + break; + case 1: + result = measure.getMeasurementValue(); + break; + default: + throw new IllegalStateException("Can't come here"); + } + return result; + } + + @Override + public boolean isCellEditable(int rowIndex, int columnIndex) { + + boolean result; + switch (columnIndex) { + case 0: + result = true; + break; + case 1: + GearUseFeaturesMeasurementSeine measure = data.get(rowIndex); + result = measure != null && measure.getGearCaracteristic() != null; + break; + default: + throw new IllegalStateException("Can't come here"); + } + return result; + + } + + @Override + public void setValueAt(Object aValue, int rowIndex, int columnIndex) { + + GearUseFeaturesMeasurementSeine measure = data.get(rowIndex); + switch (columnIndex) { + case 0: + + measure.setGearCaracteristic((GearCaracteristic) aValue); + break; + case 1: + + measure.setMeasurementValue(aValue == null ? null : String.valueOf(aValue)); + break; + + default: + throw new IllegalStateException("Can't come here"); + } + + setModified(true); + + } + + @Override + protected GearUseFeaturesMeasurementSeine createNewRow() { + return new GearUseFeaturesMeasurementSeineImpl(); + } +} \ No newline at end of file diff --git a/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeaturesSeineTableModel.java b/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeaturesSeineTableModel.java new file mode 100644 index 0000000..51e3d97 --- /dev/null +++ b/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeaturesSeineTableModel.java @@ -0,0 +1,94 @@ +package fr.ird.observe.ui.content.table.impl.seine; + +import fr.ird.observe.entities.seine.GearUseFeaturesSeine; +import fr.ird.observe.entities.seine.TripSeine; +import fr.ird.observe.ui.content.table.ContentTableMeta; +import fr.ird.observe.ui.content.table.ContentTableModel; +import fr.ird.observe.ui.content.table.ObserveContentTableUI; + +import java.util.List; + +/** + * Created on 4/7/15. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 3.16 + */ +public class GearUseFeaturesSeineTableModel extends ContentTableModel<TripSeine, GearUseFeaturesSeine> { + + private static final long serialVersionUID = 1L; + + public GearUseFeaturesSeineTableModel(ObserveContentTableUI<TripSeine, GearUseFeaturesSeine> context, + List<ContentTableMeta<GearUseFeaturesSeine>> contentTableMetas) { + super(context, contentTableMetas); + } + + @Override + public void addNewEntry() { + + int editingRow = getSelectedRow(); + + if (editingRow > -1) { + + // store sizes and weights for the selected row + // before creating a new one ? + GearUseFeaturesSeineUIModel model = getModel(); + model.getMeasurementsTableModel().storeInCacheForRow(editingRow); + + } + + super.addNewEntry(); + } + + @Override + public void updateRowFromEditBean() { + + super.updateRowFromEditBean(); + + // store sizes and weights for the selected row + + int editingRow = getSelectedRow(); + + GearUseFeaturesSeineUIModel model = getModel(); + model.getMeasurementsTableModel().storeInCacheForRow(editingRow); + + } + + @Override + protected void removeRow(int row) { + super.removeRow(row); + + // remove sizes and weights for the deleted row + // also update rows to row - 1 (when after the deleted row) + GearUseFeaturesSeineUIModel model = getModel(); + model.getMeasurementsTableModel().removeCacheForRow(row); + + } + + @Override + public void resetEditBean() { + + int row = getSelectedRow(); + if (log.isInfoEnabled()) { + log.info("Reset edit bean at row: " + row); + } + GearUseFeaturesSeineUIModel model = getModel(); + model.getMeasurementsTableModel().resetCacheForRow(row); + + super.resetEditBean(); + + } + + @Override + protected void resetRow(int row) { + super.resetRow(row); + + GearUseFeaturesSeineUIModel model = getModel(); + model.getMeasurementsTableModel().resetCacheForRow(row); + } + + @Override + protected GearUseFeaturesSeineUIModel getModel() { + return (GearUseFeaturesSeineUIModel) super.getModel(); + } +} diff --git a/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeaturesSeineUI.css b/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeaturesSeineUI.css index 9b6878f..707782e 100644 --- a/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeaturesSeineUI.css +++ b/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeaturesSeineUI.css @@ -20,6 +20,21 @@ * #L% */ +#model { + valid:{validator.isValid() && validatorTable.isValid() && getMeasurementsTableModel().isValid()}; + canSaveRow:{validatorTable.isChanged() && validatorTable.isValid() && getMeasurementsTableModel().isValid()}; + canResetRow:{validatorTable.isChanged()}; +} + +/* ***************************************************************************** */ +/* GENERAL TAB **************************************************************** */ +/* ***************************************************************************** */ + +#generalTab { + title:{t("observe.gearUseFeaturesSeine.tab.general")}; + icon:{handler.getErrorIconIfFalse(model.isGeneralTabValid())}; +} + #gearLabel { text:"observe.gearUseFeaturesSeine.gear"; labelFor:{gear}; @@ -51,11 +66,26 @@ _tablePropertyName:{GearUseFeaturesSeine.PROPERTY_USED_IN_TRIP}; } +/* ***************************************************************************** */ +/* MEASUREMENTS TAB *********************************************************** */ +/* ***************************************************************************** */ + +#measurementsFormTab { + title:{t("observe.gearUseFeaturesSeine.tab.measurements")}; + icon:{handler.getErrorIconIfFalse(measurementsTableModel.isValid())}; + enabled:{!tableModel.isCreate()}; +} + +#measurementsTable { + model: {measurementsTableModel}; +} + #comment { columnHeaderView:{new JLabel(t("observe.gearUseFeaturesSeine.comment"))}; minimumSize:{new Dimension(10,80)}; } #comment2 { + _tablePropertyName: {GearUseFeaturesSeine.PROPERTY_COMMENT}; text:{getStringValue(tableEditBean.getComment())}; } diff --git a/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeaturesSeineUI.jaxx b/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeaturesSeineUI.jaxx index f1aca39..e0242f0 100644 --- a/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeaturesSeineUI.jaxx +++ b/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeaturesSeineUI.jaxx @@ -32,6 +32,8 @@ fr.ird.observe.entities.CommentableEntity fr.ird.observe.entities.seine.TripSeine fr.ird.observe.entities.seine.GearUseFeaturesSeine + fr.ird.observe.entities.seine.GearUseFeaturesMeasurementSeine + fr.ird.observe.entities.seine.GearUseFeaturesMeasurementSeineImpl fr.ird.observe.entities.referentiel.Gear fr.ird.observe.ui.content.table.* fr.ird.observe.ui.util.BooleanEditor @@ -51,6 +53,8 @@ <!-- model --> <GearUseFeaturesSeineUIModel id='model' constructorParams='this'/> + <GearUseFeaturesMeasurementSeinesTableModel id='measurementsTableModel' initializer="getModel().getMeasurementsTableModel()"/> + <!-- edit bean --> <TripSeine id='bean'/> @@ -73,59 +77,68 @@ errorTableModel='{getErrorTableModel()}' context='n1-update'/> - <!--<JTabbedPane id='gearUseFeaturesTabPane'>--> + <Table id='editorPanel' fill='both' insets='0'> + <row> + <cell weightx="1" weighty="1"> - <!--<tab id='generalTab'>--> - <!--<JPanel layout="{new BorderLayout()}">--> - <!--</JPanel>--> - <!--</tab>--> - <!--<tab id='measurementsTab'>--> - <!--<JPanel layout="{new BorderLayout()}">--> - <!--</JPanel>--> - <!--</tab>--> - <!--</JTabbedPane>--> + <JTabbedPane id='gearUseFeaturesTabPane'> - <Table id='editorPanel' fill='both' insets='1'> + <tab id='generalTab'> - <!-- gear --> - <row> - <cell> - <JLabel id='gearLabel'/> - </cell> - <cell weightx='1' anchor='east'> - <BeanComboBox id='gear' constructorParams='this' genericType='Gear'/> - </cell> - </row> + <Table id='editForm' fill='both' insets='1'> - <!-- number --> - <row> - <cell> - <JLabel id='numberLabel'/> - </cell> - <cell weightx='1' anchor='east'> - <NumberEditor id='number' constructorParams='this'/> - </cell> - </row> + <!-- gear --> + <row> + <cell> + <JLabel id='gearLabel'/> + </cell> + <cell weightx='1' anchor='east'> + <BeanComboBox id='gear' constructorParams='this' genericType='Gear'/> + </cell> + </row> + + <!-- number --> + <row> + <cell> + <JLabel id='numberLabel'/> + </cell> + <cell weightx='1' anchor='east'> + <NumberEditor id='number' constructorParams='this'/> + </cell> + </row> + + <!-- usedInTrip --> + <row> + <cell> + <JLabel id='usedInTripLabel'/> + </cell> + <cell weightx='1' anchor='east'> + <BooleanEditor id='usedInTrip'/> + </cell> + </row> + + </Table> + + </tab> + + <tab id='measurementsFormTab'> + + <JScrollPane id='measurementsScrollPane'> + <JTable id='measurementsTable'/> + </JScrollPane> + + </tab> + </JTabbedPane> - <!-- usedInTrip --> - <row> - <cell> - <JLabel id='usedInTripLabel'/> - </cell> - <cell weightx='1' anchor='east'> - <BooleanEditor id='usedInTrip'/> </cell> </row> - - <!-- comment --> <row> - <cell columns='2' weighty='1'> + <cell weighty='1'> <JScrollPane id='comment' onFocusGained='comment2.requestFocus()'> - <JTextArea id='comment2' onKeyReleased='getTableEditBean().setComment(comment2.getText())'/> + <JTextArea id='comment2'/> </JScrollPane> </cell> </row> - </Table> <Table id='extraZone' fill='both' weightx='1' insets='0'> diff --git a/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeaturesSeineUIHandler.java b/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeaturesSeineUIHandler.java index 10eeda0..cd6f3e8 100644 --- a/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeaturesSeineUIHandler.java +++ b/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeaturesSeineUIHandler.java @@ -1,30 +1,46 @@ package fr.ird.observe.ui.content.table.impl.seine; import fr.ird.observe.DataService; +import fr.ird.observe.ObserveContext; import fr.ird.observe.ObserveDAOHelper; +import fr.ird.observe.ObserveTechnicalException; import fr.ird.observe.db.DataContext; import fr.ird.observe.db.DataSource; +import fr.ird.observe.db.DataSourceException; import fr.ird.observe.db.constants.DataContextType; import fr.ird.observe.entities.referentiel.Gear; +import fr.ird.observe.entities.referentiel.GearCaracteristic; +import fr.ird.observe.entities.seine.GearUseFeaturesMeasurementSeine; +import fr.ird.observe.entities.seine.GearUseFeaturesMeasurementSeineDAO; import fr.ird.observe.entities.seine.GearUseFeaturesSeine; import fr.ird.observe.entities.seine.TripSeine; import fr.ird.observe.ui.UIHelper; import fr.ird.observe.ui.content.ContentMode; +import fr.ird.observe.ui.content.ContentUIInitializer; import fr.ird.observe.ui.content.table.ContentTableUIHandler; +import jaxx.runtime.validator.swing.SwingValidatorMessage; +import jaxx.runtime.validator.swing.SwingValidatorMessageTableModel; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; +import org.nuiton.decorator.Decorator; import org.nuiton.topia.TopiaContext; import org.nuiton.topia.TopiaException; -import org.nuiton.topia.persistence.TopiaDAO; -import org.nuiton.topia.persistence.util.EntityListUpdator; -import org.nuiton.topia.persistence.util.Loador; +import org.nuiton.topia.persistence.util.TopiaEntityBinder; +import org.nuiton.validator.NuitonValidatorScope; +import javax.swing.JComponent; import javax.swing.JTable; +import javax.swing.event.TableModelEvent; +import javax.swing.event.TableModelListener; import javax.swing.table.DefaultTableCellRenderer; +import java.beans.PropertyChangeEvent; +import java.beans.PropertyChangeListener; import java.util.ArrayList; import java.util.Collection; +import java.util.Collections; +import java.util.HashSet; import java.util.List; -import java.util.Map; +import java.util.Set; import static org.nuiton.i18n.I18n.n; import static org.nuiton.i18n.I18n.t; @@ -38,8 +54,26 @@ import static org.nuiton.i18n.I18n.t; public class GearUseFeaturesSeineUIHandler extends ContentTableUIHandler<TripSeine, GearUseFeaturesSeine> { /** Logger */ - static private Log log = - LogFactory.getLog(GearUseFeaturesSeineUIHandler.class); + static private Log log = LogFactory.getLog(GearUseFeaturesSeineUIHandler.class); + + // Compute valid state of tab from the error table + protected final TableModelListener computeTabValidStateListener = new TableModelListener() { + @Override + public void tableChanged(TableModelEvent e) { + + SwingValidatorMessageTableModel source = (SwingValidatorMessageTableModel) e.getSource(); + computeTabValidState(source); + + } + }; + + private final PropertyChangeListener measurementsTableModelModified = new PropertyChangeListener() { + + @Override + public void propertyChange(PropertyChangeEvent evt) { + onMeasurementsTableModelModified((Boolean) evt.getNewValue()); + } + }; public GearUseFeaturesSeineUIHandler(GearUseFeaturesSeineUI ui) { super(ui, DataContextType.TripSeine); @@ -51,114 +85,367 @@ public class GearUseFeaturesSeineUIHandler extends ContentTableUIHandler<TripSei } @Override - protected ContentMode getContentMode(DataContext dataContext) { + public GearUseFeaturesSeineUIModel getModel() { + return (GearUseFeaturesSeineUIModel) super.getModel(); + } - // par defaut, on suppose qu'on peut afficher les données - getModel().setShowData(true); + @Override + protected void onSelectedRowChanged(int editingRow, GearUseFeaturesSeine bean, boolean create) { - String selectedTripId = dataContext.getSelectedTripId(); + if (log.isInfoEnabled()) { + log.info("Selected row changed: " + editingRow + ", create? " + create); + } - if (selectedTripId.equals(dataContext.getOpenTripId())) { + GearUseFeaturesSeineUI ui = getUi(); - // mode mise a jour - return ContentMode.UPDATE; + UIHelper.stopEditing(ui.getMeasurementsTable()); + + GearUseFeaturesSeineTableModel tableModel = getTableModel(); + GearUseFeaturesSeineUIModel model = getModel(); + + boolean emptySelection = editingRow == -1; + + // load size measures + + GearUseFeaturesMeasurementSeinesTableModel measurementsTableModel = model.getMeasurementsTableModel(); + List<GearUseFeaturesMeasurementSeine> measurements = emptySelection ? Collections.<GearUseFeaturesMeasurementSeine>emptyList() : measurementsTableModel.getCacheForRow(editingRow); + if (measurements == null) { + + if (log.isInfoEnabled()) { + log.info("init measurements for row " + editingRow); + } + + // first time coming on this row + + if (tableModel.isCreate()) { + + // create mode: just init with empty list + measurements = Collections.emptyList(); + + if (log.isInfoEnabled()) { + log.info("create mode, use an empty list"); + } + + } else { + + // updating mode: loading from db + try { + + measurements = getDataService().getGearUseFeaturesMeasurementSeine(getDataSource(), bean, measurementsTableModel.getLoader()); + if (log.isInfoEnabled()) { + log.info("Loaded measurements (" + bean.getTopiaId() + "): " + measurements.size()); + } + + } catch (DataSourceException e) { + throw new ObserveTechnicalException("Could not load measurements", e); + } + } + + // init measurements + measurementsTableModel.initCacheForRow(editingRow, measurements); + + } else { + + if (log.isInfoEnabled()) { + log.info("Using existing measurements for row " + editingRow + " : " + measurements.size()); + } } - // mode lecture + measurementsTableModel.setData(measurements); - if (dataContext.isSelectedTripLongline()) { + measurementsTableModel.setModified(false); + measurementsTableModel.setEditable(tableModel.isEditable()); - addInfoMessage(t("observe.tripLongline.message.not.open")); + if (!tableModel.isEditable()) { + return; + } + + JComponent requestFocus; + + if (tableModel.isCreate()) { + + // go back to first pane + ui.getGearUseFeaturesTabPane().setSelectedIndex(0); + + requestFocus = ui.getGear(); } else { - addInfoMessage(t("observe.tripSeine.message.not.open")); + requestFocus = ui.getGear(); + + } + + requestFocus.requestFocus(); + + } + + @Override + protected void initTableUI(DefaultTableCellRenderer renderer) { + + { + JTable table = getUi().getTable(); + + UIHelper.setI18nTableHeaderRenderer(table, + n("observe.gearUseFeaturesSeine.table.gear"), + n("observe.gearUseFeaturesSeine.table.gear.tip"), + n("observe.gearUseFeaturesSeine.table.number"), + n("observe.gearUseFeaturesSeine.table.number.tip"), + n("observe.gearUseFeaturesSeine.table.usedInTrip"), + n("observe.gearUseFeaturesSeine.table.usedInTrip.tip"), + n("observe.gearUseFeaturesSeine.table.comment"), + n("observe.gearUseFeaturesSeine.table.comment.tip")); + + UIHelper.setTableColumnRenderer(table, 0, UIHelper.newDecorateTableCellRenderer(renderer, Gear.class)); + UIHelper.setTableColumnRenderer(table, 1, UIHelper.newEmptyNumberTableCellRenderer(renderer)); + UIHelper.setTableColumnRenderer(table, 2, UIHelper.newBooleanTableCellRenderer(renderer)); + UIHelper.setTableColumnRenderer(table, 3, UIHelper.newStringTableCellRenderer(renderer, 10, true)); + } + + { + // init measurements table + JTable table = getUi().getMeasurementsTable(); + + UIHelper.setI18nTableHeaderRenderer(table, + n("observe.gearUseFeaturesSeine.table.gearCaracteristic"), + n("observe.gearUseFeaturesSeine.table.gearCaracteristic.tip"), + n("observe.gearUseFeaturesSeine.table.value"), + n("observe.gearUseFeaturesSeine.table.value.tip")); + + UIHelper.setTableColumnRenderer(table, 0, UIHelper.newDecorateTableCellRenderer(renderer, GearCaracteristic.class)); + UIHelper.setTableColumnRenderer(table, 1, new GearUseFeatureMeasurementCellRenderer(0, renderer)); + + table.getTableHeader().setReorderingAllowed(false); + + Decorator<GearCaracteristic> decorator = ObserveContext.get().getDecorator(GearCaracteristic.class); + + List<GearCaracteristic> list; + try { + list = getDataService().getList(getDataSource(), GearCaracteristic.class); + } catch (DataSourceException e) { + throw new ObserveTechnicalException("Could not get gear caracteristics", e); + } + UIHelper.setTableColumnEditor(table, 0, ContentUIInitializer.newDataColumnEditor(list, decorator)); + UIHelper.setTableColumnEditor(table, 1, new GearUseFeatureMeasurementCellEditor(0)); + + GearUseFeaturesMeasurementSeinesTableModel tableModel = getModel().getMeasurementsTableModel(); + tableModel.installTableKeyListener(getUi().getMeasurementsTable()); + tableModel.addPropertyChangeListener(GearUseFeaturesMeasurementSeinesTableModel.MODIFIED_PROPERTY, measurementsTableModelModified); } - return ContentMode.READ; } @Override protected String getEditBeanIdToLoad(DataContext dataContext, DataService dataService, DataSource dataSource) { - return dataContext.getSelectedTripId(); + return dataContext.getSelectedTripSeineId(); } @Override - protected void onSelectedRowChanged(int editingRow, GearUseFeaturesSeine bean, boolean create) { - if (log.isDebugEnabled()) { - log.debug("Row has changed to " + editingRow); + public void initUI() throws Exception { + + super.initUI(); + + getModel().addPropertyChangeListener(GearUseFeaturesSeineUIModel.PROPERTY_EDITABLE, new PropertyChangeListener() { + @Override + public void propertyChange(PropertyChangeEvent evt) { + Boolean newValue = (Boolean) evt.getNewValue(); + setTableModelEditable(newValue); + } + }); + + setTableModelEditable(getModel().isEditable()); + + } + + @Override + protected TripSeine loadEditBean(ContentMode mode, DataContext dataContext, DataService dataService, DataSource dataSource) throws DataSourceException { + + TripSeine tripSeine = super.loadEditBean(mode, dataContext, dataService, dataSource); + + // reset measurements + getModel().getMeasurementsTableModel().clear(); + + return tripSeine; + + } + + @Override + public void openUI() throws Exception { + + if (log.isInfoEnabled()) { + log.info("OpenUI: " + getModel()); } - if (getTableModel().isEditable()) { - getUi().getGear().requestFocus(); + + super.openUI(); + + // To be sure always remove listener (could prevent some leaks) + getUi().getErrorTableModel().removeTableModelListener(computeTabValidStateListener); + // listen messages to see if required to add + getUi().getErrorTableModel().addTableModelListener(computeTabValidStateListener); + + SwingValidatorMessageTableModel errorTableModel = getUi().getErrorTableModel(); + computeTabValidState(errorTableModel); + + } + + @Override + protected void closeSafeUI() { + + if (log.isInfoEnabled()) { + log.info("CloseUI: " + getModel()); } + super.closeSafeUI(); + + // remove listener + getUi().getErrorTableModel().removeTableModelListener(computeTabValidStateListener); + } @Override - protected void initTableUI(DefaultTableCellRenderer renderer) { - JTable table = getUi().getTable(); + public void startEditUI(String... binding) { - UIHelper.setI18nTableHeaderRenderer(table, - n("observe.gearUseFeaturesSeine.table.gear"), - n("observe.gearUseFeaturesSeine.table.gear.tip"), - n("observe.gearUseFeaturesSeine.table.number"), - n("observe.gearUseFeaturesSeine.table.number.tip"), - n("observe.gearUseFeaturesSeine.table.usedInTrip"), - n("observe.gearUseFeaturesSeine.table.usedInTrip.tip"), - n("observe.gearUseFeaturesSeine.table.comment"), - n("observe.gearUseFeaturesSeine.table.comment.tip")); + getModel().getMeasurementsTableModel().setEditable(true); + + super.startEditUI(binding); - UIHelper.setTableColumnRenderer(table, 0, UIHelper.newDecorateTableCellRenderer(renderer, Gear.class)); - UIHelper.setTableColumnRenderer(table, 1, UIHelper.newEmptyNumberTableCellRenderer(renderer)); - UIHelper.setTableColumnRenderer(table, 2, UIHelper.newBooleanTableCellRenderer(renderer)); - UIHelper.setTableColumnRenderer(table, 3, UIHelper.newStringTableCellRenderer(renderer, 10, true)); } @Override - public TripSeine onUpdate(TopiaContext tx, Object parentBean, TripSeine beanToSave) throws TopiaException { + protected void onUpdateFinalize(TopiaContext tx, TripSeine bean, Collection<GearUseFeaturesSeine> oldChilds) throws TopiaException { - List<GearUseFeaturesSeine> childs = getUi().getTableModel().getData(); + List<GearUseFeaturesSeine> gearUseFeatures = bean.getGearUseFeaturesSeine(); - Loador<GearUseFeaturesSeine> childBinder = getModel().getChildLoador(); + GearUseFeaturesSeineUIModel model = getModel(); + { - EntityListUpdator<TripSeine, GearUseFeaturesSeine> childUpdator = getModel().getChildsUpdator(); + // save measurments - // on conserve l'ancienne liste des fils (pour traitement ultérieure) - Collection<GearUseFeaturesSeine> oldChilds = new ArrayList<GearUseFeaturesSeine>(beanToSave.getGearUseFeaturesSeine()); + GearUseFeaturesMeasurementSeineDAO measureDao = ObserveDAOHelper.getGearUseFeaturesMeasurementSeineDAO(tx); - beanToSave.clearGearUseFeaturesSeine(); + GearUseFeaturesMeasurementSeinesTableModel measurementsTableModel = model.getMeasurementsTableModel(); + Set<Integer> rowsChanged = measurementsTableModel.getCacheRowsChanged(); - TopiaDAO<GearUseFeaturesSeine> dao = ObserveDAOHelper.getDAO(tx, getModel().getChildType()); + TopiaEntityBinder<GearUseFeaturesMeasurementSeine> loader = measurementsTableModel.getLoader(); + for (Integer row : rowsChanged) { - for (GearUseFeaturesSeine child : childs) { + GearUseFeaturesSeine gearUseFeaturesSeine = gearUseFeatures.get(row); - GearUseFeaturesSeine childToSave; + List<GearUseFeaturesMeasurementSeine> measurements = measurementsTableModel.getCacheForRow(row); + List<GearUseFeaturesMeasurementSeine> measurementsToSave = new ArrayList<GearUseFeaturesMeasurementSeine>(measurements.size()); - if (child.getTopiaId() == null) { + for (GearUseFeaturesMeasurementSeine measure : measurements) { - // creation du fils - Map<String, Object> map = childBinder.obtainProperties(child); - childToSave = dao.create(map); + if (measurementsTableModel.isRowNotEmpty(measure)) { - } else { + GearUseFeaturesMeasurementSeine measureToSave; + + if (measure.getTopiaId() == null) { + measureToSave = measureDao.create(measure); + loader.load(measureToSave, measure, true); + } else { + measureToSave = gearUseFeaturesSeine.getGearUseFeaturesMeasurementByTopiaId(measure.getTopiaId()); + loader.load(measure, measureToSave, true); + } + + measurementsToSave.add(measureToSave); + + } - // mise a jour du fils + } - childToSave = dao.findByTopiaId(child.getTopiaId()); + gearUseFeaturesSeine.clearGearUseFeaturesMeasurement(); + gearUseFeaturesSeine.addAllGearUseFeaturesMeasurement(measurementsToSave); - childBinder.load(child, childToSave, false); } - // ajout du fils au bean à sauver - childUpdator.addToList(beanToSave, childToSave); } - // on donne la main aux implantations pour faire des traitements - // supplémentaires - onUpdateFinalize(tx, beanToSave, oldChilds); + } + + @Override + protected void resetEditBean() { + + UIHelper.stopEditing(getUi().getMeasurementsTable()); + + super.resetEditBean(); + + } + + @Override + protected ContentMode getContentMode(DataContext dataContext) { + + // par defaut, on suppose qu'on peut afficher les données + getModel().setShowData(true); + + String selectedTripId = dataContext.getSelectedTripId(); + + if (selectedTripId.equals(dataContext.getOpenTripId())) { + + // mode mise a jour + return ContentMode.UPDATE; + } + + // mode lecture + + if (dataContext.isSelectedTripLongline()) { + + addInfoMessage(t("observe.tripLongline.message.not.open")); + + } else { + + addInfoMessage(t("observe.tripSeine.message.not.open")); + + } + + return ContentMode.READ; + } + + @Override + protected GearUseFeaturesSeineTableModel getTableModel() { + return (GearUseFeaturesSeineTableModel) super.getTableModel(); + } + + protected void setTableModelEditable(Boolean newValue) { + + getModel().getMeasurementsTableModel().setEditable(newValue); + + } + + protected void onMeasurementsTableModelModified(Boolean newValue) { + + if (newValue) { + + // modify the validator, since this is the best way to prevent table edit form actions + // that something was modified on the form + getUi().getValidatorTable().setChanged(true); + + } + + // recompute table model valid state + getModel().getMeasurementsTableModel().validate(); + + } + + + protected void computeTabValidState(SwingValidatorMessageTableModel errorTableModel) { + + Set<String> errorProperties = new HashSet<String>(); + int rowCount = errorTableModel.getRowCount(); + for (int i = 0; i < rowCount; i++) { + + SwingValidatorMessage row = errorTableModel.getRow(i); + if (NuitonValidatorScope.ERROR.equals(row.getScope())) { + errorProperties.add(row.getField()); + } + } + + boolean generalTabValid = !errorProperties.removeAll(GearUseFeaturesSeineUIModel.GENERAL_TAB_PROPERTIES); + + GearUseFeaturesSeineUIModel model = getModel(); + + model.setGeneralTabValid(generalTabValid); - return beanToSave; } } \ No newline at end of file diff --git a/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeaturesSeineUIModel.java b/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeaturesSeineUIModel.java index 0802322..bdc833d 100644 --- a/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeaturesSeineUIModel.java +++ b/observe-swing/src/main/java/fr/ird/observe/ui/content/table/impl/seine/GearUseFeaturesSeineUIModel.java @@ -1,5 +1,6 @@ package fr.ird.observe.ui.content.table.impl.seine; +import com.google.common.collect.ImmutableSet; import com.google.common.collect.Lists; import fr.ird.observe.BinderService; import fr.ird.observe.ObserveServiceHelper; @@ -9,10 +10,12 @@ import fr.ird.observe.entities.seine.TripSeine; import fr.ird.observe.ui.content.table.ContentTableMeta; import fr.ird.observe.ui.content.table.ContentTableModel; import fr.ird.observe.ui.content.table.ContentTableUIModel; +import fr.ird.observe.ui.content.table.ObserveContentTableUI; import org.nuiton.topia.persistence.util.TopiaEntityBinder; import org.nuiton.util.beans.BinderModelBuilder; import java.util.List; +import java.util.Set; /** * Created on 3/24/15. @@ -24,20 +27,47 @@ public class GearUseFeaturesSeineUIModel extends ContentTableUIModel<TripSeine, private static final long serialVersionUID = 1L; - private TopiaEntityBinder<GearUseFeaturesMeasurementSeine> gearUseFeaturesMeasurementLoador; + public static final String PROPERTY_GENERAL_TAB_VALID = "generalTabValid"; + + public static final Set<String> GENERAL_TAB_PROPERTIES = + ImmutableSet.<String>builder().add(GearUseFeaturesSeine.PROPERTY_GEAR, + GearUseFeaturesSeine.PROPERTY_NUMBER, + GearUseFeaturesSeine.PROPERTY_USED_IN_TRIP, + GearUseFeaturesSeine.PROPERTY_COMMENT).build(); + + protected boolean generalTabValid; + + private final GearUseFeaturesMeasurementSeinesTableModel measurementsTableModel; public GearUseFeaturesSeineUIModel(GearUseFeaturesSeineUI ui) { super(TripSeine.class, GearUseFeaturesSeine.class, - new String[]{TripSeine.PROPERTY_GEAR_USE_FEATURES_SEINE, TripSeine.PROPERTY_COMMENT}, + new String[]{TripSeine.PROPERTY_GEAR_USE_FEATURES_SEINE}, new String[]{ GearUseFeaturesSeine.PROPERTY_COMMENT, GearUseFeaturesSeine.PROPERTY_GEAR, GearUseFeaturesSeine.PROPERTY_NUMBER, - GearUseFeaturesSeine.PROPERTY_USED_IN_TRIP, - GearUseFeaturesSeine.PROPERTY_GEAR_USE_FEATURES_MEASUREMENT, - }); + GearUseFeaturesSeine.PROPERTY_USED_IN_TRIP}); + + BinderService binderService = ObserveServiceHelper.get().getBinderService(); + + String binderName = getClass().getName() + "-open"; + + TopiaEntityBinder<GearUseFeaturesMeasurementSeine> binder = binderService.getTopiaBinder(GearUseFeaturesMeasurementSeine.class, binderName); + + if (binder == null) { + + BinderModelBuilder<GearUseFeaturesMeasurementSeine, GearUseFeaturesMeasurementSeine> builder = + binderService.newBinderBuilder(GearUseFeaturesMeasurementSeine.class, + GearUseFeaturesMeasurementSeine.PROPERTY_GEAR_CARACTERISTIC, + GearUseFeaturesMeasurementSeine.PROPERTY_MEASUREMENT_VALUE); + + binder = binderService.registerTopiaBinder(GearUseFeaturesMeasurementSeine.class, builder, binderName); + + } + + this.measurementsTableModel = new GearUseFeaturesMeasurementSeinesTableModel(binder); List<ContentTableMeta<GearUseFeaturesSeine>> metas = Lists.newArrayList( ContentTableModel.newTableMeta(GearUseFeaturesSeine.class, GearUseFeaturesSeine.PROPERTY_GEAR, false), @@ -50,30 +80,21 @@ public class GearUseFeaturesSeineUIModel extends ContentTableUIModel<TripSeine, } @Override - protected BinderModelBuilder<GearUseFeaturesSeine, GearUseFeaturesSeine> prepareChildLoador(BinderService binderService, String binderName) { - - BinderModelBuilder<GearUseFeaturesSeine, GearUseFeaturesSeine> builder = super.prepareChildLoador(binderService, binderName); - builder.addCollectionBinder(getGearUseFeaturesMeasurementLoador(), GearUseFeaturesSeine.PROPERTY_GEAR_USE_FEATURES_MEASUREMENT); - return builder; - + protected GearUseFeaturesSeineTableModel createTableModel(ObserveContentTableUI<TripSeine, GearUseFeaturesSeine> ui, List<ContentTableMeta<GearUseFeaturesSeine>> contentTableMetas) { + return new GearUseFeaturesSeineTableModel(ui, contentTableMetas); } - public TopiaEntityBinder<GearUseFeaturesMeasurementSeine> getGearUseFeaturesMeasurementLoador() { - if (gearUseFeaturesMeasurementLoador == null) { - - BinderService binderService = ObserveServiceHelper.get().getBinderService(); - - String binderName = getClass().getName() + "-open"; - - BinderModelBuilder<GearUseFeaturesMeasurementSeine, GearUseFeaturesMeasurementSeine> builder = - binderService.newBinderBuilder(GearUseFeaturesMeasurementSeine.class, - GearUseFeaturesMeasurementSeine.PROPERTY_GEAR_CARACTERISTIC, - GearUseFeaturesMeasurementSeine.PROPERTY_MEASUREMENT_VALUE); + public GearUseFeaturesMeasurementSeinesTableModel getMeasurementsTableModel() { + return measurementsTableModel; + } - gearUseFeaturesMeasurementLoador = binderService.registerTopiaBinder(GearUseFeaturesMeasurementSeine.class, builder, binderName); + public boolean isGeneralTabValid() { + return generalTabValid; + } - } - return gearUseFeaturesMeasurementLoador; + public void setGeneralTabValid(boolean generalTabValid) { + this.generalTabValid = generalTabValid; + firePropertyChange(PROPERTY_GENERAL_TAB_VALID, null, isGeneralTabValid()); } } \ No newline at end of file diff --git a/observe-swing/src/main/resources/i18n/observe-swing_en_GB.properties b/observe-swing/src/main/resources/i18n/observe-swing_en_GB.properties index 3a979a0..9e6ca24 100644 --- a/observe-swing/src/main/resources/i18n/observe-swing_en_GB.properties +++ b/observe-swing/src/main/resources/i18n/observe-swing_en_GB.properties @@ -1037,14 +1037,22 @@ observe.gear.unit=Unit observe.gearUseFeaturesSeine.comment=Comment observe.gearUseFeaturesSeine.gear=Gear observe.gearUseFeaturesSeine.number=Number +observe.gearUseFeaturesSeine.tab.general= +observe.gearUseFeaturesSeine.tab.measurements= observe.gearUseFeaturesSeine.table.comment=Comment observe.gearUseFeaturesSeine.table.comment.tip=Comment observe.gearUseFeaturesSeine.table.gear=Gear observe.gearUseFeaturesSeine.table.gear.tip=Gear +observe.gearUseFeaturesSeine.table.gearCaracteristic= +observe.gearUseFeaturesSeine.table.gearCaracteristic.tip= observe.gearUseFeaturesSeine.table.number=Number observe.gearUseFeaturesSeine.table.number.tip=Number +observe.gearUseFeaturesSeine.table.size= +observe.gearUseFeaturesSeine.table.size.tip= observe.gearUseFeaturesSeine.table.usedInTrip=Used observe.gearUseFeaturesSeine.table.usedInTrip.tip=Used in trip +observe.gearUseFeaturesSeine.table.value= +observe.gearUseFeaturesSeine.table.value.tip= observe.gearUseFeaturesSeine.title= observe.gearUseFeaturesSeine.usedInTrip=Used in trip observe.harbour.coordinates= diff --git a/observe-swing/src/main/resources/i18n/observe-swing_es_ES.properties b/observe-swing/src/main/resources/i18n/observe-swing_es_ES.properties index 574d445..b990dfe 100644 --- a/observe-swing/src/main/resources/i18n/observe-swing_es_ES.properties +++ b/observe-swing/src/main/resources/i18n/observe-swing_es_ES.properties @@ -1037,14 +1037,22 @@ observe.gear.unit= observe.gearUseFeaturesSeine.comment= observe.gearUseFeaturesSeine.gear= observe.gearUseFeaturesSeine.number= +observe.gearUseFeaturesSeine.tab.general= +observe.gearUseFeaturesSeine.tab.measurements= observe.gearUseFeaturesSeine.table.comment= observe.gearUseFeaturesSeine.table.comment.tip= observe.gearUseFeaturesSeine.table.gear= observe.gearUseFeaturesSeine.table.gear.tip= +observe.gearUseFeaturesSeine.table.gearCaracteristic= +observe.gearUseFeaturesSeine.table.gearCaracteristic.tip= observe.gearUseFeaturesSeine.table.number= observe.gearUseFeaturesSeine.table.number.tip= +observe.gearUseFeaturesSeine.table.size= +observe.gearUseFeaturesSeine.table.size.tip= observe.gearUseFeaturesSeine.table.usedInTrip= observe.gearUseFeaturesSeine.table.usedInTrip.tip= +observe.gearUseFeaturesSeine.table.value= +observe.gearUseFeaturesSeine.table.value.tip= observe.gearUseFeaturesSeine.title= observe.gearUseFeaturesSeine.usedInTrip= observe.harbour.coordinates= diff --git a/observe-swing/src/main/resources/i18n/observe-swing_fr_FR.properties b/observe-swing/src/main/resources/i18n/observe-swing_fr_FR.properties index 7d435d4..900636e 100644 --- a/observe-swing/src/main/resources/i18n/observe-swing_fr_FR.properties +++ b/observe-swing/src/main/resources/i18n/observe-swing_fr_FR.properties @@ -96,8 +96,8 @@ observe.action.create=Créer observe.action.create.activity=Créer une nouvelle activité observe.action.create.activity.tip=Créer une nouvelle activité pour la route courante observe.action.create.entry.tip=Créer une nouvelle entrée -observe.action.create.gearUseFeaturesSeine= -observe.action.create.gearUseFeaturesSeine.tip= +observe.action.create.gearUseFeaturesSeine=Créer un équipement +observe.action.create.gearUseFeaturesSeine.tip=Créer un nouvel équipement observe.action.create.maree=Créer une nouvelle marée observe.action.create.maree.tip=Créer une nouvelle marée pour le programme courant observe.action.create.nonTargetCatch=Insérer cette espèce / poids / devenir @@ -1037,14 +1037,20 @@ observe.gear.unit=Unité observe.gearUseFeaturesSeine.comment=Commentaire observe.gearUseFeaturesSeine.gear=Équipement observe.gearUseFeaturesSeine.number=Nombre +observe.gearUseFeaturesSeine.tab.general=Définition +observe.gearUseFeaturesSeine.tab.measurements=Caractéristiques observe.gearUseFeaturesSeine.table.comment=Commentaire observe.gearUseFeaturesSeine.table.comment.tip=Commentaire observe.gearUseFeaturesSeine.table.gear=Équipement observe.gearUseFeaturesSeine.table.gear.tip=Équipement +observe.gearUseFeaturesSeine.table.gearCaracteristic=Caractéristique +observe.gearUseFeaturesSeine.table.gearCaracteristic.tip=Caractéristique observe.gearUseFeaturesSeine.table.number=Nombre observe.gearUseFeaturesSeine.table.number.tip=Nombre observe.gearUseFeaturesSeine.table.usedInTrip=Utilisé observe.gearUseFeaturesSeine.table.usedInTrip.tip=Utilisé dans la marée +observe.gearUseFeaturesSeine.table.value=Valeur +observe.gearUseFeaturesSeine.table.value.tip=Valeur observe.gearUseFeaturesSeine.title=Équipements observe.gearUseFeaturesSeine.usedInTrip=Utilisé dans la marée observe.harbour.coordinates=Nom -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.