+    public static final KeyStroke KEY_STROKE_EXPAND_TREE_TABLE_NODE = KeyStroke.getKeyStroke("ctrl released RIGHT");

+    public static final KeyStroke KEY_STROKE_COLLAPSE_TREE_TABLE_NODE = KeyStroke.getKeyStroke("ctrl released LEFT");

+    fr.ird.observe.client.ui.content.data.seine.dcp.FloatingObjectPartsTreeTable

+                      <FloatingObjectPartsTreeTable id='table' constructorParams="new FloatingObjectPartsTreeTableModel(getModel())"/>

+        FloatingObjectUIModel model = getModel();

+        model.setForm(form);

+        model.reset();

+        getUi().getTable().openTable(model, partsSet, bean.isPersisted());

+        model.setReference(floatingObjectReference.orElse(null));

+    @Override

+    public void stopEditUI() {

+        if (ui.getMainTabbedPane().getSelectedIndex() == 1) {

+            ui.getTable().editingCanceled(null);

+        super.stopEditUI();

+        ui.getTable().initTable(model, () -> getUi().getPreferredSize().width - 200, detailedForm);

+        FloatingObjectPartsTreeTableModel treeModel = getUi().getTable().getTreeTableModel();

+    public void setPartsModified() {

+import fr.ird.observe.client.ObserveSwingApplicationContext;

+import fr.ird.observe.dto.referential.ReferentialLocale;

+        if (dto == null) {

+            root = new FloatingObjectPartsTreeNode(rootModel);

+        } else {

+        getUserObject().needOneSelectionOnArriving = false;

+        getUserObject().needOneSelectionOnLeaving = false;

+    ImmutableSet<FloatingObjectPartsTreeNode> getShell() {

+        ImmutableSet.Builder<FloatingObjectPartsTreeNode> allNodesBuilder = ImmutableSet.builder();

+        getShell(allNodesBuilder);

+        return allNodesBuilder.build();

+    }

+    private void getShell(ImmutableSet.Builder<FloatingObjectPartsTreeNode> allNodesBuilder) {

+        allNodesBuilder.add(this);

+            child.getShell(allNodesBuilder);

+    }

+    boolean withMandatoryConstraintsOnChildren() {

+        ObjectMaterialHierarchyDto userObject = getUserObject().dto;

+        return userObject == null || userObject.isChildSelectionMandatory();

+        boolean needSelect = isEditable();

+        FloatingObjectPartsTreeNodeContext userObject = getUserObject();

+            userObject.needOneSelectionOnArriving = (!needSelect || withValue(1)) && isAtLeastOneSelected(1);

+            userObject.needOneSelectionOnLeaving = (!needSelect || withValue(2)) && isAtLeastOneSelected(2);

+        }

+        if (userObject.needOneSelectionOnArriving || userObject.needOneSelectionOnLeaving) {

+            log.info("Validate node " + this);

+    private FloatingObjectPartsTreeNode getFirstAncestorNeedOneSelection(int column) {

+        if (withMandatoryConstraintsOnChildren()) {

+            if (parent == null) {

+                return this;

+            }

+            if (withValue(column)) {

+                return this;

+            }

+        return getParent().getFirstAncestorNeedOneSelection(column);

+    void computeMandatoryValidState(boolean whenArriving, boolean whenLeaving) {

+        FloatingObjectPartsTreeNodeContext userObject = getUserObject();

+        FloatingObjectPartsTreeNode parent = getParent();

+        if (whenArriving) {

+            if (parent != null && !parent.getUserObject().validWhenArriving) {

+                userObject.validWhenArriving = false;

+            } else {

+                userObject.validWhenArriving = getFirstAncestorNeedOneSelection(1).getUserObject().needOneSelectionOnArriving;

+        if (whenLeaving) {

+            if (parent != null && !parent.getUserObject().validWhenLeaving) {

+                userObject.validWhenLeaving = false;

+            } else {

+                userObject.validWhenLeaving = getFirstAncestorNeedOneSelection(2).getUserObject().needOneSelectionOnLeaving;

+        if (userObject.getValueAt(1) != null || userObject.getValueAt(2) != null) {

+            log.info("Validate node " + this);

+        }

+//    void computeFormulaValidState(boolean whenArriving, boolean whenLeaving) {

+//        FloatingObjectPartsTreeNodeContext userObject = getUserObject();

+//        ObjectMaterialHierarchyDto dto = Objects.requireNonNull(userObject.dto);

+//        if (whenArriving && userObject.validWhenArriving) {

+//            Object value = userObject.getValueAt(1);

+//            userObject.validWhenArriving = dto.isValid(value);

+//        }

+//        if (whenLeaving && userObject.validWhenLeaving) {

+//            Object value = userObject.getValueAt(2);

+//            userObject.validWhenLeaving = dto.isValid(value);

+//        }

+//

+//    }

+    private boolean withValue(int column) {

+        return getValueAt(column) != null;

+    }

+

+    private boolean withValidValue(int column) {

+        return withValue(column) && (column == 1 ? getUserObject().valueValidOnArriving : getUserObject().valueValidOnLeaving);

+    }

+

+            if (child.withValidValue(column)) {

+                return true;

+            }

+            boolean result = child.isAtLeastOneSelected(column);

+            if (result) {

+    //TODO Improve the design, we should not store anything in uiModel and separate leaving and arriving data

+        // Is the node use validation on his value ?

+        private final boolean useValidation;

+        private final ReferentialLocale referentialLocale;

+        // Is this node (on arriving) need at least one child selected ? (if editable then node must be selected)

+        private boolean needOneSelectionOnLeaving;

+        // Is this node (on leaving) need at least one child selected ? (if editable then node must be selected)

+        private boolean needOneSelectionOnArriving;

+        // for a validation node (on arriving), is value valid (if no value then it is valid)

+        private boolean valueValidOnLeaving = true;

+        // for a validation node (on leaving), is value valid (if no value then it is valid)

+        private boolean valueValidOnArriving = true;

+        // Is the node valid (on arriving) column ?

+        // Is the node valid (on leeaving) column ?

+            this.uiModel = Objects.requireNonNull(uiModel);

+            this.useValidation = false;

+            this.valueValidOnArriving = true;

+            this.valueValidOnLeaving = true;

+            this.referentialLocale = ObserveSwingApplicationContext.get().getDecoratorService().getReferentialLocale();

+            this.uiModel = Objects.requireNonNull(parent).uiModel;

+            this.dto = Objects.requireNonNull(dto);

+            this.useValidation = enabled && editable && dto.withValidation();

+            if (!useValidation) {

+                valueValidOnArriving = true;

+                valueValidOnLeaving = true;

+            }

+            this.referentialLocale = ObserveSwingApplicationContext.get().getDecoratorService().getReferentialLocale();

+            log.info(String.format("New node: %s %s - needOneSelection %b-%b - exclusive %s", dto.getCode(), dto.getLabel(referentialLocale), needOneSelectionOnArriving, needOneSelectionOnLeaving, exclusive));

+            text = null;

+                    if (useValidation) {

+                        valueValidOnArriving = dto.isValid(aValue);

+                    }

+                    if (useValidation) {

+                        valueValidOnLeaving = dto.isValid(aValue);

+                    }

+                text = String.format("%s [value: %s-%s] [valid: %s-%s]", dto.getLabel(referentialLocale), getValueAt(1), getValueAt(2), isValid(1), isValid(2));

+package fr.ird.observe.client.ui.content.data.seine.dcp;

+

+/*-

+ * #%L

+ * ObServe :: Client

+ * %%

+ * Copyright (C) 2008 - 2018 IRD, Code Lutin, Ultreia.io

+ * %%

+ * This program is free software: you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as

+ * published by the Free Software Foundation, either version 3 of the

+ * License, or (at your option) any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public

+ * License along with this program.  If not, see

+ * <http://www.gnu.org/licenses/gpl-3.0.html>.

+ * #L%

+ */

+

+import fr.ird.observe.client.ObserveSwingApplicationContext;

+import fr.ird.observe.client.ui.ObserveKeyStrokes;

+import fr.ird.observe.client.ui.content.data.seine.FloatingObjectUIModel;

+import fr.ird.observe.dto.data.seine.FloatingObjectPartReference;

+import fr.ird.observe.dto.data.seine.ObjectMaterialHierarchyDto;

+import org.apache.log4j.lf5.viewer.categoryexplorer.TreeModelAdapter;

+import org.jdesktop.swingx.JXTable;

+import org.jdesktop.swingx.JXTreeTable;

+import org.jdesktop.swingx.decorator.ColorHighlighter;

+import org.jdesktop.swingx.table.ColumnFactory;

+import org.jdesktop.swingx.table.TableColumnExt;

+import org.jdesktop.swingx.treetable.MutableTreeTableNode;

+

+import javax.swing.AbstractAction;

+import javax.swing.ActionMap;

+import javax.swing.InputMap;

+import javax.swing.ListSelectionModel;

+import javax.swing.SwingUtilities;

+import javax.swing.event.TreeModelEvent;

+import javax.swing.tree.TreePath;

+import java.awt.Color;

+import java.awt.event.ActionEvent;

+import java.util.Enumeration;

+import java.util.Objects;

+import java.util.Set;

+import java.util.function.Supplier;

+

+/**

+ * Created by tchemit on 11/07/2018.

+ *

+ * @author Tony Chemit - dev@tchemit.fr

+ */

+public class FloatingObjectPartsTreeTable extends JXTreeTable {

+

+    public FloatingObjectPartsTreeTable(FloatingObjectPartsTreeTableModel treeModel) {

+        super(treeModel);

+        setTreeCellRenderer(new FloatingObjectPartLegendTreeCellRenderer());

+        setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

+        setRootVisible(false);

+    }

+

+    @Override

+    public FloatingObjectPartsTreeTableModel getTreeTableModel() {

+        return (FloatingObjectPartsTreeTableModel) super.getTreeTableModel();

+    }

+

+    public void openTable(FloatingObjectUIModel model, Set<FloatingObjectPartReference> partsSet, boolean persisted) {

+

+        for (FloatingObjectPartReference p : partsSet) {

+            String objectMaterialId = p.getObjectMaterialId();

+            String whenArriving = p.getWhenArriving();

+            String whenLeaving = p.getWhenLeaving();

+            if (whenArriving != null && !Objects.equals("false", whenArriving)) {

+                model.setWhenArriving(objectMaterialId, whenArriving);

+            }

+            if (whenLeaving != null && !Objects.equals("false", whenLeaving)) {

+                model.setWhenLeaving(objectMaterialId, whenLeaving);

+            }

+        }

+

+        FloatingObjectPartsTreeTableModel treeTableModel = getTreeTableModel();

+        treeTableModel.reset();

+

+        if (persisted) {

+            expandAll();

+        } else {

+            // expand first level nodes (except if they are disabled)

+            FloatingObjectPartsTreeNode root = treeTableModel.getRoot();

+            Enumeration<? extends MutableTreeTableNode> children = root.children();

+            while (children.hasMoreElements()) {

+                FloatingObjectPartsTreeNode mutableTreeTableNode = (FloatingObjectPartsTreeNode) children.nextElement();

+                if (mutableTreeTableNode.isEnabled()) {

+                    SwingUtilities.invokeLater(() -> expandPath(new TreePath(new Object[]{root, mutableTreeTableNode})));

+                }

+            }

+        }

+        // auto expand nodes when selected

+        addTreeSelectionListener(e -> {

+            int selectedRow = getSelectedRow();

+            if (selectedRow != -1) {

+                if (!isExpanded(selectedRow)) {

+                    SwingUtilities.invokeLater(() -> expandRow(selectedRow));

+                }

+            }

+        });

+    }

+

+    public void initTable(FloatingObjectUIModel model, Supplier<Integer> width, ObjectMaterialHierarchyDto materials) {

+

+        FloatingObjectPartsTreeTableModel treeModel = getTreeTableModel();

+        treeModel.rebuildRootNode(materials);

+

+        setColumnFactory(new ColumnFactory() {

+

+            @Override

+            public void configureColumnWidths(JXTable table, TableColumnExt columnExt) {

+                if (table.getColumn(0).equals(columnExt)) {

+                    columnExt.setPreferredWidth(width.get());

+                    columnExt.setMinWidth(columnExt.getPreferredWidth());

+                    return;

+                }

+                super.configureColumnWidths(table, columnExt);

+                columnExt.setMinWidth(columnExt.getPreferredWidth());

+            }

+        });

+        treeModel.addTreeModelListener(new TreeModelAdapter() {

+            @Override

+            public void treeNodesChanged(TreeModelEvent e) {

+                if (treeModel.isAdjusting()) {

+                    return;

+                }

+                model.setModified(true);

+                model.setPartsModified();

+            }

+

+        });

+

+        setDefaultRenderer(Object.class, new FloatingObjectPartsTableCellRenderer(this));

+        setDefaultEditor(Object.class, new FloatingObjectPartsTableCellEditor(this));

+        addHighlighter(new ColorHighlighter((renderer, adapter) -> {

+            JXTreeTable component = (JXTreeTable) adapter.getComponent();

+            int row = adapter.convertRowIndexToModel(adapter.row);

+            FloatingObjectPartsTreeNode node = (FloatingObjectPartsTreeNode) component.getPathForRow(row).getLastPathComponent();

+            boolean valid1 = node.isValid(1);

+            boolean valid2 = node.isValid(2);

+            switch (adapter.convertRowIndexToModel(adapter.column)) {

+                case 0:

+                    return false;

+                case 1:

+                    return !valid1;

+                case 2:

+                    return !valid2;

+            }

+            return true;

+        }, ObserveSwingApplicationContext.get().getConfig().getFloatingObjectMaterialErrorColor(), Color.WHITE));

+

+        InputMap inputMap = getInputMap(WHEN_IN_FOCUSED_WINDOW);

+        ActionMap actionMap = getActionMap();

+        inputMap.put(ObserveKeyStrokes.KEY_STROKE_EXPAND_TREE_TABLE_NODE,"expandNode");

+        actionMap.put("expandNode", new AbstractAction() {

+            @Override

+            public void actionPerformed(ActionEvent e) {

+                int selectedRow = getSelectedRow();

+                if (selectedRow != -1) {

+                    if (!isExpanded(selectedRow)) {

+                        SwingUtilities.invokeLater(() -> expandRow(selectedRow));

+                    }

+                }

+            }

+        });

+        inputMap.put(ObserveKeyStrokes.KEY_STROKE_COLLAPSE_TREE_TABLE_NODE,"collapseNode");

+        actionMap.put("collapseNode", new AbstractAction() {

+            @Override

+            public void actionPerformed(ActionEvent e) {

+                int selectedRow = getSelectedRow();

+                if (selectedRow != -1) {

+                    if (!isCollapsed(selectedRow)) {

+                        SwingUtilities.invokeLater(() -> collapseRow(selectedRow));

+                    }

+                }

+            }

+        });

+    }

+}

+        allNodes = ((FloatingObjectPartsTreeNode) root).getShell();