+observe.ui.datasource.editor.actions.data.copy

+observe.ui.datasource.editor.actions.data.delete

+observe.ui.datasource.editor.actions.data.delete.result

+observe.ui.datasource.editor.actions.data.export.result

+observe.ui.datasource.editor.actions.data.import.add.missing.referential

+observe.ui.datasource.editor.actions.data.import.add.missing.referential.for.type

+observe.ui.datasource.editor.actions.data.import.result

+observe.ui.datasource.editor.actions.data.import.title.require.add.missing.referential

+import java.util.stream.Collectors;

+import java.util.stream.Stream;

+    @SuppressWarnings({"unchecked", "rawtypes"})

+                                               t("observe.ui.datasource.editor.actions.data.import.title.require.add.missing.referential", getTargetSourceLabel()),

+        StringBuilder parameters = new StringBuilder();

+            decoratorService.installDecorator(key, (Stream) references.stream());

+            String labels = references.stream().map(Object::toString).collect(Collectors.joining("\n\t * "));

+            parameters.append(t("observe.ui.datasource.editor.actions.data.import.add.missing.referential.for.type", getTargetSourceLabel(), references.size(), type, labels));

+            parameters.append("\n");

+        action.sendMessage(t("observe.ui.datasource.editor.actions.data.import.add.missing.referential", getTargetSourceLabel(), parameters.toString()));

+

+        action.sendMessage(t("observe.ui.datasource.editor.actions.data.delete", getTargetSourceLabel(), program, trip));

+        logDeleteResult(n("observe.ui.datasource.editor.actions.data.delete.result"),

+        action.sendMessage(t("observe.ui.datasource.editor.actions.data.copy", targetSourceLabel, program, trip));

+        logExportResult(n("observe.ui.datasource.editor.actions.data.export.result"),

+        log.info("Use import script: " + importTripRequest.getSqlContent().getLocation());

+        logImportResult(n("observe.ui.datasource.editor.actions.data.import.result"),

+                        n("observe.ui.datasource.editor.actions.data.delete.result"),

+        super(t("observe.ui.action.apply"), t("observe.ui.action.apply"), "accept", 'S');

+        super(t("observe.ui.action.apply"), t("observe.ui.action.apply"), "accept", 'S');

+observe.ui.choice.apply

+observe.ui.choice.cancel.tip

+observe.ui.move.selectTarget

+    public static final KeyStroke KEY_STROKE_SELECT_TARGET = KeyStroke.getKeyStroke("pressed F2");

+

+                //FIXME:Tree No on a such referential node, there is no child! no no need to do this

+                //FIXME:Test use a less brutal node method

+    /**

+     * to select target node after move operation.

+     */

+    private final boolean selectTarget;

+    public MoveRequest(Class<? extends DataDtoReference> referenceType, Class<? extends DtoReference> parentReferenceType, Class<? extends DtoReference> parentTargetReferenceType, String oldParentId, ImmutableSet<String> ids, String newParentId, boolean selectTarget) {

+        this.selectTarget = selectTarget;

+    public boolean isSelectTarget() {

+        return selectTarget;

+    }

+

+import fr.ird.observe.client.datasource.editor.api.ObserveKeyStrokesEditorApi;

+import javax.swing.AbstractAction;

+import javax.swing.Action;

+import javax.swing.ActionMap;

+import javax.swing.InputMap;

+import javax.swing.JCheckBox;

+import javax.swing.JComponent;

+import javax.swing.JLayeredPane;

+import javax.swing.JSeparator;

+import javax.swing.KeyStroke;

+import javax.swing.SwingConstants;

+import javax.swing.SwingUtilities;

+import java.awt.Font;

+import java.awt.GridLayout;

+import java.awt.event.ActionEvent;

+@SuppressWarnings("UnusedReturnValue")

+    /**

+     * To get selected target request value.

+     */

+    private final JCheckBox selectTarget;

+    private final AbstractAction selectTargetAction;

+    private final AbstractAction applyAction;

+    private JButton jButton;

+    private JOptionPane optionPane;

+        KeyStroke keyStroke = ObserveKeyStrokesEditorApi.KEY_STROKE_SELECT_TARGET;

+        String t = ObserveKeyStrokesEditorApi.suffixTextWithKeyStroke(t("observe.ui.move.selectTarget"), keyStroke);

+        this.selectTarget = new JCheckBox(t);

+        selectTargetAction = new AbstractAction() {

+            @Override

+            public void actionPerformed(ActionEvent e) {

+                selectTarget.setSelected(!selectTarget.isSelected());

+                log.info(String.format("select target? %s", selectTarget.isSelected()));

+            }

+        };

+        selectTargetAction.putValue(Action.ACCELERATOR_KEY, keyStroke);

+        selectTargetAction.putValue(Action.NAME, t);

+        selectTarget.setFocusable(false);

+        keyStroke = ObserveKeyStrokesEditorApi.KEY_STROKE_APPLY;

+        t = ObserveKeyStrokesEditorApi.suffixTextWithKeyStroke(t("observe.ui.choice.apply"), keyStroke);

+

+        applyAction = new AbstractAction() {

+            @Override

+            public void actionPerformed(ActionEvent e) {

+                log.info("Apply :)");

+                jButton.doClick();

+            }

+        };

+        applyAction.putValue(Action.ACCELERATOR_KEY, keyStroke);

+        applyAction.putValue(Action.NAME, t);

+//        selectTarget.setAction(selectTargetAction);

+        return Optional.of(new MoveRequest(referenceType, parentReferenceType, parentTargetReferenceType, oldParentId, ids, newParentId, selectTarget.isSelected()));

+        String continueActionText = (String) applyAction.getValue(Action.NAME);

+        Object[] options = {continueActionText};

+        JPanel panel = new JPanel(new BorderLayout(3, 3));

+

+        JPanel panel0 = new JPanel(new BorderLayout(3, 3));

+

+        JPanel panel2 = new JPanel(new GridLayout(0, 1));

+

+        panel0.add(BorderLayout.NORTH, new JLabel(t(dialogMessage)));

+        panel0.add(BorderLayout.CENTER, editor);

+        panel0.add(BorderLayout.SOUTH, panel2);

+

+        //FIXME:Move Add a default client configuration option to set this value

+        selectTarget.setSelected(false);

+

+        panel2.add(new JLabel());

+        panel2.add(selectTarget);

+

+        JLabel information = new JLabel(t("observe.ui.choice.cancel.tip"), UIHelper.getUIManagerActionIcon("information"), SwingConstants.LEFT);

+        information.setFont(information.getFont().deriveFont(Font.ITALIC).deriveFont(11f));

+

+        JPanel panel4 = new JPanel(new GridLayout(0, 1));

+        JPanel panel5 = new JPanel(new BorderLayout());

+        panel4.add(panel5);

+        panel4.add(BorderLayout.NORTH, new JSeparator(SwingConstants.HORIZONTAL));

+        panel4.add(BorderLayout.CENTER, information);

+        panel.add(BorderLayout.NORTH, panel0);

+        panel.add(BorderLayout.SOUTH, panel4);

+        InputMap inputMap1 = panel.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);

+        inputMap1.put((KeyStroke) selectTargetAction.getValue(Action.ACCELERATOR_KEY), "selectTarget");

+

+        InputMap inputMap = panel.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);

+        inputMap.put((KeyStroke) selectTargetAction.getValue(Action.ACCELERATOR_KEY), "selectTarget");

+        inputMap.put((KeyStroke) applyAction.getValue(Action.ACCELERATOR_KEY), "apply");

+

+        ActionMap actionMap = panel.getActionMap();

+        actionMap.put("selectTarget", selectTargetAction);

+        actionMap.put("apply", applyAction);

+

+        optionPane = new JOptionPane(panel, JOptionPane.QUESTION_MESSAGE, JOptionPane.DEFAULT_OPTION, null, options, options[0]) {

+            @Override

+            public void selectInitialValue() {

+

+                JLayeredPane parent = (JLayeredPane) optionPane.getParent().getParent();

+

+                InputMap inputMap = parent.getRootPane().getInputMap(2);

+

+                inputMap.put(KeyStroke.getKeyStroke("pressed ENTER"), "none");

+                inputMap.put(KeyStroke.getKeyStroke("ctrl pressed ENTER"), "none");

+

+                SwingUtilities.invokeLater(editor.getCombobox()::requestFocus);

+            }

+        };

+        jButton = UsageUIHandlerSupport.findButton(optionPane, continueActionText);

+        int response = UIHelper.askUser(ClientUIContextApplicationComponent.value().getMainUI(), optionPane, t(dialogTitle), options);

+import com.google.common.collect.ImmutableSet;

+import fr.ird.observe.client.datasource.editor.api.content.data.list.ContentListUINavigationNode;

+import fr.ird.observe.client.datasource.editor.api.navigation.tree.root.RootNavigationNode;

+import fr.ird.observe.dto.referential.common.ProgramReference;

+        ImmutableSet<String> ids = request.getIds();

+        // get old parent node

+        ContentListUINavigationNode oldParentNode = (ContentListUINavigationNode) tree.getSelectedNode().upToReferenceContainerNode(request.getReferenceType());

+        // get shared ancestor of tow parents

+        NavigationNode parentContainerNode = oldParentNode.upToReferenceContainerNode(request.getParentReferenceType());

+        // get new parent node

+        ContentListUINavigationNode newParentNode = getNewParentNode(request, parentContainerNode);

+        // update it

+        newParentNode.addChildren(ids);

+

+        // clean old paren node

+        cleanOldParentNode(tree, ids, oldParentNode);

+

+        if (request.isSelectTarget()) {

+            // select new parent node

+            tree.selectSafeNode(newParentNode);

+        } else {

+            if (oldParentNode.getParent() == null) {

+                // limit case: select first node in tree (previous old parent node was removed)

+                tree.selectFirstNode();

+            }

+        }

+    }

+

+    protected void cleanOldParentNode(NavigationTree tree, ImmutableSet<String> ids, ContentListUINavigationNode oldParentNode) {

+        if (oldParentNode.getChildCount() == ids.size() && oldParentNode.getParent().isRoot()) {

+            RootNavigationNode root = (RootNavigationNode) oldParentNode.getParent();

+            if (!root.getInitializer().getConfig().isLoadEmptyProgram()) {

+                // limit case : node will be empty, must remove it

+                root.remove(oldParentNode);

+                return;

+            }

+        }

+        // clean it

+        oldParentNode.removeChildren(ids);

+

+        // reload node

+        oldParentNode.reloadNodeData();

+

+        // re-select the node (to update associated form)

+        tree.reSelectSafeNode(oldParentNode);

+    }

+

+    protected ContentListUINavigationNode getNewParentNode(MoveRequest request, NavigationNode oldParentContainerNode) {

+        String newParentId = request.getNewParentId();

+        if (oldParentContainerNode.isRoot()) {

+            RootNavigationNode root = (RootNavigationNode) oldParentContainerNode;

+            boolean loadEmptyProgram = root.getInitializer().getConfig().isLoadEmptyProgram();

+            if (!loadEmptyProgram) {

+                NavigationNode result = root.findChildById(newParentId);

+                if (result == null) {

+                    // limit case : node does not exist (was empty previously), need to create it

+                    ProgramReference reference = root.getInitializer().getNavigationResult().getProgram(newParentId);

+                    result = root.getCapability().createChildNode(reference);

+                    int position = root.getCapability().getNodePosition(reference);

+                    root.insert(result, position);

+                }

+                return (ContentListUINavigationNode) result;

+            }

+        }

+        return (ContentListUINavigationNode) oldParentContainerNode.downToReferenceNode(request.getParentTargetReferenceType(), newParentId);

+}

+  enabled:{states.isEditable() && states.isOneOrMoreSelectedData()};

+import com.google.common.collect.ImmutableSet;

+import java.util.Set;

+    public void removeChildren(ImmutableSet<String> ids) {

+        for (String id : ids) {

+            NavigationNode childNode = findChildById(id);

+            childNode.removeFromParent();

+        }

+    }

+

+    public void addChildren(Set<String> ids) {

+        ContentListUINavigationInitializer initializer = getInitializer();

+        boolean notLoaded = isNotLoaded();

+        reloadNodeData();

+        List<? extends DataDtoReference> references = initializer.getReferences();

+        ContentListUINavigationCapability<?> capability = getCapability();

+        for (DataDtoReference reference : references) {

+            if (notLoaded || ids.contains(reference.getId())) {

+                NavigationNode childNode = capability.createChildNode(reference);

+                int nodePosition = capability.getNodePosition(reference);

+                insert(childNode, nodePosition);

+            }

+        }

+    }

+    public final <R extends DtoReference> int getChildrenPosition(R reference, Comparator<R> referenceComparator) {

+public class RootNavigationCapability implements ReferenceContainerCapability<RootNavigationNode> {

+        this.acceptedTypes = SingletonSupplier.of(() -> getNode().getInitializer().getRootNodeProviders().stream().map(RootNavigationTreeNodeProvider::getAcceptedType).filter(Objects::nonNull).distinct().collect(ImmutableList.toImmutableList()));

+        return getNode().getChildrenPosition((ProgramReference) reference, ProgramReference.COMPARATOR_WITH_GEAR_PREFIX);

+import fr.ird.observe.dto.reference.DtoReference;

+    private final Class<? extends DtoReference> acceptedType;

+    protected RootNavigationTreeNodeProvider(BusinessProject project, B module, ImmutableList<Class<? extends NavigationNode>> acceptedNodeTypes, Class<? extends DtoReference> acceptedType) {

+    public Class<? extends DtoReference> getAcceptedType() {

+              ProgramReference.class);

+              ProgramReference.class);

+observe.ui.choice.apply=Apply

+observe.ui.choice.cancel.tip=To cancel, press ESCAPE key. 

+observe.ui.datasource.editor.actions.data.copy=Database «%s» - Register operation copy to database\: %s - %s

+observe.ui.datasource.editor.actions.data.delete=Database «%s» - Register operation delete from database\: %s - %s

+observe.ui.datasource.editor.actions.data.delete.result=Database «%s» - Trip %s - %s was removed from database.

+observe.ui.datasource.editor.actions.data.export.result=Database «%s» - Trip %s - %s was exported from database.

+observe.ui.datasource.editor.actions.data.import.add.missing.referential=Database «%s» - Insert all missing referentials\n%s

+observe.ui.datasource.editor.actions.data.import.add.missing.referential.for.type=Database «%s» - Insert %s missing referentials of type «%s»\:%s

+observe.ui.datasource.editor.actions.data.import.result=Database «%s» - Trip %s - %s was imported into database.

+observe.ui.datasource.editor.actions.data.import.title.require.add.missing.referential=Need to confirm missing referential insertion