* This dialog is for editing relations.

*

*/

    /** the tag table and its model */

    private TagEditorPanel tagEditorPanel;

    private ReferringRelationsBrowser referrerBrowser;

    private ReferringRelationsBrowserModel referrerModel;

    /** the member table */

    private MemberTable memberTable;

    private MemberTableModel memberTableModel;

    /** the model for the selection table */

    private SelectionTable selectionTable;

    private SelectionTableModel selectionTableModel;

    private AutoCompletingTextField tfRole;

    /** the menu item in the windows menu. Required to properly

     * hide on dialog close.

     */

    private JMenuItem windowMenuItem;

    /**

     * Creates a new relation editor for the given relation. The relation will be saved if the user

     * selects "ok" in the editor.

     *

     * If no relation is given, will create an editor for a new relation.

     *

     * @param layer the {@link OsmDataLayer} the new or edited relation belongs to

     * @param relation relation to edit, or null to create a new one.

     * @param selectedMembers a collection of members which shall be selected initially

     */

    public GenericRelationEditor(OsmDataLayer layer, Relation relation, Collection<RelationMember> selectedMembers) {

        super(layer, relation, selectedMembers);

        setRememberWindowGeometry(getClass().getName() + ".geometry",

                WindowGeometry.centerInWindow(Main.parent, new Dimension(700, 650)));

        final PresetHandler presetHandler = new PresetHandler() {

            @Override

            public void updateTags(List<Tag> tags) {

                tagEditorPanel.getModel().updateTags(tags);

            }

            @Override

            public Collection<OsmPrimitive> getSelection() {

                Relation relation = new Relation();

                tagEditorPanel.getModel().applyToPrimitive(relation);

                return Collections.<OsmPrimitive>singletonList(relation);

            }

        };

        // init the various models

        //

        memberTableModel = new MemberTableModel(getLayer(), presetHandler);

        memberTableModel.register();

        selectionTableModel = new SelectionTableModel(getLayer());

        selectionTableModel.register();

        referrerModel = new ReferringRelationsBrowserModel(relation);

        tagEditorPanel = new TagEditorPanel(presetHandler);

        // populate the models

        //

        if (relation != null) {

            tagEditorPanel.getModel().initFromPrimitive(relation);

            this.memberTableModel.populate(relation);

            if (!getLayer().data.getRelations().contains(relation)) {

                // treat it as a new relation if it doesn't exist in the

                // data set yet.

                setRelation(null);

            }

        } else {

            tagEditorPanel.getModel().clear();

            this.memberTableModel.populate(null);

        }

        tagEditorPanel.getModel().ensureOneTag();

        JSplitPane pane = buildSplitPane();

        pane.setPreferredSize(new Dimension(100, 100));

        JPanel pnl = new JPanel();

        pnl.setLayout(new BorderLayout());

        pnl.add(pane, BorderLayout.CENTER);

        pnl.setBorder(BorderFactory.createRaisedBevelBorder());

        getContentPane().setLayout(new BorderLayout());

        JTabbedPane tabbedPane = new JTabbedPane();

        tabbedPane.add(tr("Tags and Members"), pnl);

        referrerBrowser = new ReferringRelationsBrowser(getLayer(), referrerModel);

        tabbedPane.add(tr("Parent Relations"), referrerBrowser);

        tabbedPane.add(tr("Child Relations"), new ChildRelationBrowser(getLayer(), relation));

        tabbedPane.addChangeListener(

                new ChangeListener() {

                    @Override

                    public void stateChanged(ChangeEvent e) {

                        JTabbedPane sourceTabbedPane = (JTabbedPane) e.getSource();

                        int index = sourceTabbedPane.getSelectedIndex();

                        String title = sourceTabbedPane.getTitleAt(index);

                        if (title.equals(tr("Parent Relations"))) {

                            referrerBrowser.init();

                        }

                    }

                }

        );

        getContentPane().add(buildToolBar(), BorderLayout.NORTH);

        getContentPane().add(tabbedPane, BorderLayout.CENTER);

        getContentPane().add(buildOkCancelButtonPanel(), BorderLayout.SOUTH);

        setSize(findMaxDialogSize());

        addWindowListener(

                new WindowAdapter() {

                    @Override

                    public void windowOpened(WindowEvent e) {

                        cleanSelfReferences();

                    }

                }

        );

        registerCopyPasteAction(tagEditorPanel.getPasteAction(),

                "PASTE_TAGS",

                Shortcut.registerShortcut("system:pastestyle", tr("Edit: {0}", tr("Paste Tags")), KeyEvent.VK_V, Shortcut.CTRL_SHIFT).getKeyStroke());

        registerCopyPasteAction(new PasteMembersAction(), "PASTE_MEMBERS", Shortcut.getPasteKeyStroke());

        registerCopyPasteAction(new CopyMembersAction(), "COPY_MEMBERS", Shortcut.getCopyKeyStroke());

        tagEditorPanel.setNextFocusComponent(memberTable);

        selectionTable.setFocusable(false);

        memberTableModel.setSelectedMembers(selectedMembers);

        HelpUtil.setHelpContext(getRootPane(),ht("/Dialog/RelationEditor"));

    }

    /**

     * Creates the toolbar

     *

     * @return the toolbar

     */

    protected JToolBar buildToolBar() {

        JToolBar tb  = new JToolBar();

        tb.setFloatable(false);

        tb.add(new ApplyAction());

        tb.add(new DuplicateRelationAction());

        DeleteCurrentRelationAction deleteAction = new DeleteCurrentRelationAction();

        addPropertyChangeListener(deleteAction);

        tb.add(deleteAction);

        return tb;

    }

    /**

     * builds the panel with the OK and the Cancel button

     *

     * @return the panel with the OK and the Cancel button

     */

    protected JPanel buildOkCancelButtonPanel() {

        JPanel pnl = new JPanel();

        pnl.setLayout(new FlowLayout(FlowLayout.CENTER));

        pnl.add(new SideButton(new OKAction()));

        pnl.add(new SideButton(new CancelAction()));

        pnl.add(new SideButton(new ContextSensitiveHelpAction(ht("/Dialog/RelationEditor"))));

        return pnl;

    }

    /**

     * builds the panel with the tag editor

     *

     * @return the panel with the tag editor

     */

    protected JPanel buildTagEditorPanel() {

        JPanel pnl = new JPanel();

        pnl.setLayout(new GridBagLayout());

        GridBagConstraints gc = new GridBagConstraints();

        gc.gridx = 0;

        gc.gridy = 0;

        gc.gridheight = 1;

        gc.gridwidth = 1;

        gc.fill = GridBagConstraints.HORIZONTAL;

        gc.anchor = GridBagConstraints.FIRST_LINE_START;

        gc.weightx = 1.0;

        gc.weighty = 0.0;

        pnl.add(new JLabel(tr("Tags")), gc);

        gc.gridx = 0;

        gc.gridy = 1;

        gc.fill = GridBagConstraints.BOTH;

        gc.anchor = GridBagConstraints.CENTER;

        gc.weightx = 1.0;

        gc.weighty = 1.0;

        pnl.add(tagEditorPanel, gc);

        return pnl;

    }

    /**

     * builds the panel for the relation member editor

     *

     * @return the panel for the relation member editor

     */

    protected JPanel buildMemberEditorPanel() {

        final JPanel pnl = new JPanel();

        pnl.setLayout(new GridBagLayout());

        // setting up the member table

        memberTable = new MemberTable(getLayer(),memberTableModel);

        memberTable.addMouseListener(new MemberTableDblClickAdapter());

        memberTableModel.addMemberModelListener(memberTable);

        final JScrollPane scrollPane = new JScrollPane(memberTable);

        GridBagConstraints gc = new GridBagConstraints();

        gc.gridx = 0;

        gc.gridy = 0;

        gc.gridwidth = 2;

        gc.fill = GridBagConstraints.HORIZONTAL;

        gc.anchor = GridBagConstraints.FIRST_LINE_START;

        gc.weightx = 1.0;

        gc.weighty = 0.0;

        pnl.add(new JLabel(tr("Members")), gc);

        gc.gridx = 0;

        gc.gridy = 1;

        gc.gridheight = 2;

        gc.gridwidth = 1;

        gc.fill = GridBagConstraints.VERTICAL;

        gc.anchor = GridBagConstraints.NORTHWEST;

        gc.weightx = 0.0;

        gc.weighty = 1.0;

        pnl.add(buildLeftButtonPanel(), gc);

        gc.gridx = 1;

        gc.gridy = 1;

        gc.gridheight = 1;

        gc.fill = GridBagConstraints.BOTH;

        gc.anchor = GridBagConstraints.CENTER;

        gc.weightx = 0.6;

        gc.weighty = 1.0;

        pnl.add(scrollPane, gc);

        // --- role editing

        JPanel p3 = new JPanel(new FlowLayout(FlowLayout.LEFT));

        p3.add(new JLabel(tr("Apply Role:")));

        tfRole = new AutoCompletingTextField(10);

        tfRole.setToolTipText(tr("Enter a role and apply it to the selected relation members"));

        tfRole.addFocusListener(new FocusAdapter() {

            @Override

            public void focusGained(FocusEvent e) {

                tfRole.selectAll();

            }

        });

        tfRole.setAutoCompletionList(new AutoCompletionList());

        tfRole.addFocusListener(

                new FocusAdapter() {

                    @Override

                    public void focusGained(FocusEvent e) {

                        AutoCompletionList list = tfRole.getAutoCompletionList();

                        if (list != null) {

                            list.clear();

                            getLayer().data.getAutoCompletionManager().populateWithMemberRoles(list);

                        }

                    }

                }

        );

        tfRole.setText(Main.pref.get("relation.editor.generic.lastrole", ""));

        p3.add(tfRole);

        SetRoleAction setRoleAction = new SetRoleAction();

        memberTableModel.getSelectionModel().addListSelectionListener(setRoleAction);

        tfRole.getDocument().addDocumentListener(setRoleAction);

        tfRole.addActionListener(setRoleAction);

        memberTableModel.getSelectionModel().addListSelectionListener(

                new ListSelectionListener() {

                    @Override

                    public void valueChanged(ListSelectionEvent e) {

                        tfRole.setEnabled(memberTable.getSelectedRowCount() > 0);

                    }

                }

        );

        tfRole.setEnabled(memberTable.getSelectedRowCount() > 0);

        SideButton btnApply = new SideButton(setRoleAction);

        btnApply.setPreferredSize(new Dimension(20,20));

        btnApply.setText("");

        p3.add(btnApply);

        gc.gridx = 1;

        gc.gridy = 2;

        gc.fill = GridBagConstraints.HORIZONTAL;

        gc.anchor = GridBagConstraints.LAST_LINE_START;

        gc.weightx = 1.0;

        gc.weighty = 0.0;

        pnl.add(p3, gc);

        JPanel pnl2 = new JPanel();

        pnl2.setLayout(new GridBagLayout());

        gc.gridx = 0;

        gc.gridy = 0;

        gc.gridheight = 1;

        gc.gridwidth = 3;

        gc.fill = GridBagConstraints.HORIZONTAL;

        gc.anchor = GridBagConstraints.FIRST_LINE_START;

        gc.weightx = 1.0;

        gc.weighty = 0.0;

        pnl2.add(new JLabel(tr("Selection")), gc);

        gc.gridx = 0;

        gc.gridy = 1;

        gc.gridheight = 1;

        gc.gridwidth = 1;

        gc.fill = GridBagConstraints.VERTICAL;

        gc.anchor = GridBagConstraints.NORTHWEST;

        gc.weightx = 0.0;

        gc.weighty = 1.0;

        pnl2.add(buildSelectionControlButtonPanel(), gc);

        gc.gridx = 1;

        gc.gridy = 1;

        gc.weightx = 1.0;

        gc.weighty = 1.0;

        gc.fill = GridBagConstraints.BOTH;

        pnl2.add(buildSelectionTablePanel(), gc);

        final JSplitPane splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);

        splitPane.setLeftComponent(pnl);

        splitPane.setRightComponent(pnl2);

        splitPane.setOneTouchExpandable(false);

        addWindowListener(new WindowAdapter() {

            @Override

            public void windowOpened(WindowEvent e) {

                // has to be called when the window is visible, otherwise

                // no effect

                splitPane.setDividerLocation(0.6);

            }

        });

        JPanel pnl3 = new JPanel();

        pnl3.setLayout(new BorderLayout());

        pnl3.add(splitPane, BorderLayout.CENTER);

        return pnl3;

    }

    /**

     * builds the panel with the table displaying the currently selected primitives

     *

     * @return panel with current selection

     */

    protected JPanel buildSelectionTablePanel() {

        JPanel pnl = new JPanel();

        pnl.setLayout(new BorderLayout());

        selectionTable = new SelectionTable(selectionTableModel, new SelectionTableColumnModel(memberTableModel));

        selectionTable.setMemberTableModel(memberTableModel);

        selectionTable.setRowHeight(tfRole.getPreferredSize().height);

        JScrollPane pane = new JScrollPane(selectionTable);

        pnl.add(pane, BorderLayout.CENTER);

        return pnl;

    }

    /**

     * builds the {@link JSplitPane} which divides the editor in an upper and a lower half

     *

     * @return the split panel

     */

    protected JSplitPane buildSplitPane() {

        final JSplitPane pane = new JSplitPane(JSplitPane.VERTICAL_SPLIT);

        pane.setTopComponent(buildTagEditorPanel());

        pane.setBottomComponent(buildMemberEditorPanel());

        pane.setOneTouchExpandable(true);

        addWindowListener(new WindowAdapter() {

            @Override

            public void windowOpened(WindowEvent e) {

                // has to be called when the window is visible, otherwise

                // no effect

                pane.setDividerLocation(0.3);

            }

        });

        return pane;

    }

    /**

     * build the panel with the buttons on the left

     *

     * @return left button panel

     */

    protected JToolBar buildLeftButtonPanel() {

        JToolBar tb = new JToolBar();

        tb.setOrientation(JToolBar.VERTICAL);

        tb.setFloatable(false);

        // -- move up action

        MoveUpAction moveUpAction = new MoveUpAction();

        memberTableModel.getSelectionModel().addListSelectionListener(moveUpAction);

        tb.add(moveUpAction);

        memberTable.getActionMap().put("moveUp", moveUpAction);

        // -- move down action

        MoveDownAction moveDownAction = new MoveDownAction();

        memberTableModel.getSelectionModel().addListSelectionListener(moveDownAction);

        tb.add(moveDownAction);

        memberTable.getActionMap().put("moveDown", moveDownAction);

        tb.addSeparator();

        // -- edit action

        EditAction editAction = new EditAction();

        memberTableModel.getSelectionModel().addListSelectionListener(editAction);

        tb.add(editAction);

        // -- delete action

        RemoveAction removeSelectedAction = new RemoveAction();

        memberTable.getSelectionModel().addListSelectionListener(removeSelectedAction);

        tb.add(removeSelectedAction);

        memberTable.getActionMap().put("removeSelected", removeSelectedAction);

        tb.addSeparator();

        // -- sort action

        SortAction sortAction = new SortAction();

        memberTableModel.addTableModelListener(sortAction);

        tb.add(sortAction);

        // -- reverse action

        ReverseAction reverseAction = new ReverseAction();

        memberTableModel.addTableModelListener(reverseAction);

        tb.add(reverseAction);

        tb.addSeparator();

        // -- download action

        DownloadIncompleteMembersAction downloadIncompleteMembersAction = new DownloadIncompleteMembersAction();

        memberTable.getModel().addTableModelListener(downloadIncompleteMembersAction);

        tb.add(downloadIncompleteMembersAction);

        memberTable.getActionMap().put("downloadIncomplete", downloadIncompleteMembersAction);

        // -- download selected action

        DownloadSelectedIncompleteMembersAction downloadSelectedIncompleteMembersAction = new DownloadSelectedIncompleteMembersAction();

        memberTable.getModel().addTableModelListener(downloadSelectedIncompleteMembersAction);

        memberTable.getSelectionModel().addListSelectionListener(downloadSelectedIncompleteMembersAction);

        tb.add(downloadSelectedIncompleteMembersAction);

        InputMap inputMap = memberTable.getInputMap(MemberTable.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);

        inputMap.put((KeyStroke) removeSelectedAction.getValue(AbstractAction.ACCELERATOR_KEY),"removeSelected");

        inputMap.put((KeyStroke) moveUpAction.getValue(AbstractAction.ACCELERATOR_KEY),"moveUp");

        inputMap.put((KeyStroke) moveDownAction.getValue(AbstractAction.ACCELERATOR_KEY),"moveDown");

        inputMap.put((KeyStroke) downloadIncompleteMembersAction.getValue(AbstractAction.ACCELERATOR_KEY),"downloadIncomplete");

        return tb;

    }

    /**

     * build the panel with the buttons for adding or removing the current selection

     *

     * @return control buttons panel for selection/members

     */

    protected JToolBar buildSelectionControlButtonPanel() {

        JToolBar tb = new JToolBar(JToolBar.VERTICAL);

        tb.setFloatable(false);

        // -- add at start action

        AddSelectedAtStartAction addSelectionAction = new AddSelectedAtStartAction();

        selectionTableModel.addTableModelListener(addSelectionAction);

        tb.add(addSelectionAction);

        // -- add before selected action

        AddSelectedBeforeSelection addSelectedBeforeSelectionAction = new AddSelectedBeforeSelection();

        selectionTableModel.addTableModelListener(addSelectedBeforeSelectionAction);

        memberTableModel.getSelectionModel().addListSelectionListener(addSelectedBeforeSelectionAction);

        tb.add(addSelectedBeforeSelectionAction);

        // -- add after selected action

        AddSelectedAfterSelection addSelectedAfterSelectionAction = new AddSelectedAfterSelection();

        selectionTableModel.addTableModelListener(addSelectedAfterSelectionAction);

        memberTableModel.getSelectionModel().addListSelectionListener(addSelectedAfterSelectionAction);

        tb.add(addSelectedAfterSelectionAction);

        // -- add at end action

        AddSelectedAtEndAction addSelectedAtEndAction = new AddSelectedAtEndAction();

        selectionTableModel.addTableModelListener(addSelectedAtEndAction);

        tb.add(addSelectedAtEndAction);

        tb.addSeparator();

        // -- select members action

        SelectedMembersForSelectionAction selectMembersForSelectionAction = new SelectedMembersForSelectionAction();

        selectionTableModel.addTableModelListener(selectMembersForSelectionAction);

        memberTableModel.addTableModelListener(selectMembersForSelectionAction);

        tb.add(selectMembersForSelectionAction);

        // -- select action

        SelectPrimitivesForSelectedMembersAction selectAction = new SelectPrimitivesForSelectedMembersAction();

        memberTable.getSelectionModel().addListSelectionListener(selectAction);

        tb.add(selectAction);

        tb.addSeparator();

        // -- remove selected action

        RemoveSelectedAction removeSelectedAction = new RemoveSelectedAction();

        selectionTableModel.addTableModelListener(removeSelectedAction);

        tb.add(removeSelectedAction);

        return tb;

    }

    @Override

    protected Dimension findMaxDialogSize() {

        return new Dimension(700, 650);

    }

    @Override

    public void setVisible(boolean visible) {

        if (visible) {

            tagEditorPanel.initAutoCompletion(getLayer());

        }

        super.setVisible(visible);

        if (visible) {

            RelationDialogManager.getRelationDialogManager().positionOnScreen(this);

            if(windowMenuItem == null) {

                addToWindowMenu();

            }

            tagEditorPanel.requestFocusInWindow();

        } else {

            // make sure all registered listeners are unregistered

            //

            memberTable.stopHighlighting();

            selectionTableModel.unregister();

            memberTableModel.unregister();

            memberTable.unlinkAsListener();

            if(windowMenuItem != null) {

                Main.main.menu.windowMenu.remove(windowMenuItem);

                windowMenuItem = null;

            }

            dispose();

        }

    }

    /** adds current relation editor to the windows menu (in the "volatile" group) o*/

    protected void addToWindowMenu() {

        String name = getRelation() == null ? tr("New Relation") : getRelation().getLocalName();

        final String tt = tr("Focus Relation Editor with relation ''{0}'' in layer ''{1}''",

                name, getLayer().getName());

        name = tr("Relation Editor: {0}", name == null ? getRelation().getId() : name);

        final JMenu wm = Main.main.menu.windowMenu;

        final JosmAction focusAction = new JosmAction(name, "dialogs/relationlist", tt, null, false, false) {

            @Override

            public void actionPerformed(ActionEvent e) {

                final RelationEditor r = (RelationEditor) getValue("relationEditor");

                r.setVisible(true);

            }

        };

        focusAction.putValue("relationEditor", this);

        windowMenuItem = MainMenu.add(wm, focusAction, MainMenu.WINDOW_MENU_GROUP.VOLATILE);

    }

    /**

     * checks whether the current relation has members referring to itself. If so,

     * warns the users and provides an option for removing these members.

     *

     */

    protected void cleanSelfReferences() {

        List<OsmPrimitive> toCheck = new ArrayList<>();

        toCheck.add(getRelation());

        if (memberTableModel.hasMembersReferringTo(toCheck)) {

            int ret = ConditionalOptionPaneUtil.showOptionDialog(

                    "clean_relation_self_references",

                    Main.parent,

                    tr("<html>There is at least one member in this relation referring<br>"

                            + "to the relation itself.<br>"

                            + "This creates circular dependencies and is discouraged.<br>"

                            + "How do you want to proceed with circular dependencies?</html>"),

                            tr("Warning"),

                            JOptionPane.YES_NO_OPTION,

                            JOptionPane.WARNING_MESSAGE,

                            new String[]{tr("Remove them, clean up relation"), tr("Ignore them, leave relation as is")},

                            tr("Remove them, clean up relation")

            );

            switch(ret) {

            case ConditionalOptionPaneUtil.DIALOG_DISABLED_OPTION: return;

            case JOptionPane.CLOSED_OPTION: return;

            case JOptionPane.NO_OPTION: return;

            case JOptionPane.YES_OPTION:

                memberTableModel.removeMembersReferringTo(toCheck);

                break;

            }

        }

    }

    private void registerCopyPasteAction(AbstractAction action, Object actionName, KeyStroke shortcut) {

        int mods = shortcut.getModifiers();

        int code = shortcut.getKeyCode();

        if (code!=KeyEvent.VK_INSERT && (mods == 0 || mods == InputEvent.SHIFT_DOWN_MASK)) {

            Main.info(tr("Sorry, shortcut \"{0}\" can not be enabled in Relation editor dialog"), shortcut);

            return;

        }

        getRootPane().getActionMap().put(actionName, action);

        getRootPane().getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(shortcut, actionName);

        // Assign also to JTables because they have their own Copy&Paste implementation (which is disabled in this case but eats key shortcuts anyway)

        memberTable.getInputMap(JComponent.WHEN_FOCUSED).put(shortcut, actionName);

        memberTable.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(shortcut, actionName);

        memberTable.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(shortcut, actionName);

        selectionTable.getInputMap(JComponent.WHEN_FOCUSED).put(shortcut, actionName);

        selectionTable.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(shortcut, actionName);

        selectionTable.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(shortcut, actionName);

    }

    static class AddAbortException extends Exception {

    }

    static boolean confirmAddingPrimitive(OsmPrimitive primitive) throws AddAbortException {

        String msg = tr("<html>This relation already has one or more members referring to<br>"

                + "the object ''{0}''<br>"

                + "<br>"

                + "Do you really want to add another relation member?</html>",

                primitive.getDisplayName(DefaultNameFormatter.getInstance())

            );

        int ret = ConditionalOptionPaneUtil.showOptionDialog(

                "add_primitive_to_relation",

                Main.parent,

                msg,

                tr("Multiple members referring to same object."),

                JOptionPane.YES_NO_CANCEL_OPTION,

                JOptionPane.WARNING_MESSAGE,

                null,

                null

        );

        switch(ret) {

        case ConditionalOptionPaneUtil.DIALOG_DISABLED_OPTION : return true;

        case JOptionPane.YES_OPTION: return true;

        case JOptionPane.NO_OPTION: return false;

        case JOptionPane.CLOSED_OPTION: return false;

        case JOptionPane.CANCEL_OPTION: throw new AddAbortException();

        }

        // should not happen

        return false;

    }

    static void warnOfCircularReferences(OsmPrimitive primitive) {

        String msg = tr("<html>You are trying to add a relation to itself.<br>"

                + "<br>"

                + "This creates circular references and is therefore discouraged.<br>"

                + "Skipping relation ''{0}''.</html>",

                primitive.getDisplayName(DefaultNameFormatter.getInstance()));

        JOptionPane.showMessageDialog(

                Main.parent,

                msg,

                tr("Warning"),

                JOptionPane.WARNING_MESSAGE);

    }

    public static Command addPrimitivesToRelation(final Relation orig, Collection<? extends OsmPrimitive> primitivesToAdd) throws IllegalArgumentException {

        CheckParameterUtil.ensureParameterNotNull(orig, "orig");

        try {

            final Collection<TaggingPreset> presets = TaggingPreset.getMatchingPresets(EnumSet.of(TaggingPresetType.RELATION), orig.getKeys(), false);

            Relation relation = new Relation(orig);

            boolean modified = false;

            for (OsmPrimitive p : primitivesToAdd) {

                if (p instanceof Relation && orig.equals(p)) {

                    warnOfCircularReferences(p);

                    continue;

                } else if (MemberTableModel.hasMembersReferringTo(relation.getMembers(), Collections.singleton(p))

                        && !confirmAddingPrimitive(p)) {

                    continue;

                }

                final String role = presets.isEmpty() ? null : presets.iterator().next().suggestRoleForOsmPrimitive(p);

                relation.addMember(new RelationMember(role == null ? "" : role, p));

                modified = true;

            }

            return modified ? new ChangeCommand(orig, relation) : null;

        } catch (AddAbortException ign) {

            return null;

        }

    }

    abstract class AddFromSelectionAction extends AbstractAction {

        protected boolean isPotentialDuplicate(OsmPrimitive primitive) {

            return memberTableModel.hasMembersReferringTo(Collections.singleton(primitive));

        }

        protected List<OsmPrimitive> filterConfirmedPrimitives(List<OsmPrimitive> primitives) throws AddAbortException {

            if (primitives == null || primitives.isEmpty())

                return primitives;

            List<OsmPrimitive> ret = new ArrayList<>();

            ConditionalOptionPaneUtil.startBulkOperation("add_primitive_to_relation");

            for (OsmPrimitive primitive : primitives) {

                if (primitive instanceof Relation && getRelation() != null && getRelation().equals(primitive)) {

                    warnOfCircularReferences(primitive);

                    continue;

                }

                if (isPotentialDuplicate(primitive)) {

                    if (confirmAddingPrimitive(primitive)) {

                        ret.add(primitive);

                    }

                    continue;

                } else {

                    ret.add(primitive);

                }

            }

            ConditionalOptionPaneUtil.endBulkOperation("add_primitive_to_relation");

            return ret;

        }

    }

    class AddSelectedAtStartAction extends AddFromSelectionAction implements TableModelListener {

        public AddSelectedAtStartAction() {

            putValue(SHORT_DESCRIPTION,

                    tr("Add all objects selected in the current dataset before the first member"));

            putValue(SMALL_ICON, ImageProvider.get("dialogs/conflict", "copystartright"));

            refreshEnabled();

        }

        protected void refreshEnabled() {

            setEnabled(selectionTableModel.getRowCount() > 0);

        }

        @Override

        public void actionPerformed(ActionEvent e) {

            try {

                List<OsmPrimitive> toAdd = filterConfirmedPrimitives(selectionTableModel.getSelection());

                memberTableModel.addMembersAtBeginning(toAdd);

            } catch(AddAbortException ex) {

                // do nothing

            }

        }

        @Override

        public void tableChanged(TableModelEvent e) {

            refreshEnabled();

        }

    }

    class AddSelectedAtEndAction extends AddFromSelectionAction implements TableModelListener {

        public AddSelectedAtEndAction() {

            putValue(SHORT_DESCRIPTION, tr("Add all objects selected in the current dataset after the last member"));

            putValue(SMALL_ICON, ImageProvider.get("dialogs/conflict", "copyendright"));

            refreshEnabled();

        }

        protected void refreshEnabled() {

            setEnabled(selectionTableModel.getRowCount() > 0);

        }

        @Override

        public void actionPerformed(ActionEvent e) {

            try {

                List<OsmPrimitive> toAdd = filterConfirmedPrimitives(selectionTableModel.getSelection());

                memberTableModel.addMembersAtEnd(toAdd);

            } catch(AddAbortException ex) {

                // do nothing

            }

        }

        @Override

        public void tableChanged(TableModelEvent e) {

            refreshEnabled();

        }

    }

    class AddSelectedBeforeSelection extends AddFromSelectionAction implements TableModelListener, ListSelectionListener {

        public AddSelectedBeforeSelection() {

            putValue(SHORT_DESCRIPTION,

                    tr("Add all objects selected in the current dataset before the first selected member"));

            putValue(SMALL_ICON, ImageProvider.get("dialogs/conflict", "copybeforecurrentright"));

            refreshEnabled();

        }

        protected void refreshEnabled() {

            setEnabled(selectionTableModel.getRowCount() > 0

                    && memberTableModel.getSelectionModel().getMinSelectionIndex() >= 0);

        }

        @Override

        public void actionPerformed(ActionEvent e) {

            try {

                List<OsmPrimitive> toAdd = filterConfirmedPrimitives(selectionTableModel.getSelection());

                memberTableModel.addMembersBeforeIdx(toAdd, memberTableModel

                        .getSelectionModel().getMinSelectionIndex());

            } catch(AddAbortException ex) {

                // do nothing

            }

        }

        @Override

        public void tableChanged(TableModelEvent e) {

            refreshEnabled();

        }

        @Override

        public void valueChanged(ListSelectionEvent e) {

            refreshEnabled();

        }

    }

    class AddSelectedAfterSelection extends AddFromSelectionAction implements TableModelListener, ListSelectionListener {

        public AddSelectedAfterSelection() {

            putValue(SHORT_DESCRIPTION,

                    tr("Add all objects selected in the current dataset after the last selected member"));

            putValue(SMALL_ICON, ImageProvider.get("dialogs/conflict", "copyaftercurrentright"));

            refreshEnabled();

        }

        protected void refreshEnabled() {

            setEnabled(selectionTableModel.getRowCount() > 0

                    && memberTableModel.getSelectionModel().getMinSelectionIndex() >= 0);

        }

        @Override

        public void actionPerformed(ActionEvent e) {

            try {

                List<OsmPrimitive> toAdd = filterConfirmedPrimitives(selectionTableModel.getSelection());

                memberTableModel.addMembersAfterIdx(toAdd, memberTableModel

                        .getSelectionModel().getMaxSelectionIndex());

            } catch(AddAbortException ex) {

                // do nothing

            }

        }

        @Override

        public void tableChanged(TableModelEvent e) {

            refreshEnabled();

        }

        @Override

        public void valueChanged(ListSelectionEvent e) {

            refreshEnabled();

        }

    }

    class RemoveSelectedAction extends AbstractAction implements TableModelListener {

        public RemoveSelectedAction() {

            putValue(SHORT_DESCRIPTION, tr("Remove all members referring to one of the selected objects"));

            putValue(SMALL_ICON, ImageProvider.get("dialogs/relation", "deletemembers"));

            updateEnabledState();

        }

        protected void updateEnabledState() {

            DataSet ds = getLayer().data;

            if (ds == null || ds.getSelected().isEmpty()) {

                setEnabled(false);

                return;

            }

            // only enable the action if we have members referring to the

            // selected primitives

            //

            setEnabled(memberTableModel.hasMembersReferringTo(ds.getSelected()));

        }

        @Override

        public void actionPerformed(ActionEvent e) {

            memberTableModel.removeMembersReferringTo(selectionTableModel.getSelection());

        }

        @Override

        public void tableChanged(TableModelEvent e) {

            updateEnabledState();

        }

    }

    /**

     * Selects  members in the relation editor which refer to primitives in the current

     * selection of the context layer.

     *

     */

    class SelectedMembersForSelectionAction extends AbstractAction implements TableModelListener {

        public SelectedMembersForSelectionAction() {

            putValue(SHORT_DESCRIPTION, tr("Select relation members which refer to objects in the current selection"));

            putValue(SMALL_ICON, ImageProvider.get("dialogs/relation", "selectmembers"));

            updateEnabledState();

        }

        protected void updateEnabledState() {

            boolean enabled = selectionTableModel.getRowCount() > 0

            &&  !memberTableModel.getChildPrimitives(getLayer().data.getSelected()).isEmpty();

            if (enabled) {

                putValue(SHORT_DESCRIPTION, tr("Select relation members which refer to {0} objects in the current selection",memberTableModel.getChildPrimitives(getLayer().data.getSelected()).size()));

            } else {

                putValue(SHORT_DESCRIPTION, tr("Select relation members which refer to objects in the current selection"));

            }

            setEnabled(enabled);

        }

        @Override

        public void actionPerformed(ActionEvent e) {

            memberTableModel.selectMembersReferringTo(getLayer().data.getSelected());

        }

        @Override

        public void tableChanged(TableModelEvent e) {

            updateEnabledState();

        }

    }

    /**

     * Selects primitives in the layer this editor belongs to. The selected primitives are

     * equal to the set of primitives the currently selected relation members refer to.

     *

     */

    class SelectPrimitivesForSelectedMembersAction extends AbstractAction implements ListSelectionListener {

        public SelectPrimitivesForSelectedMembersAction() {

            putValue(SHORT_DESCRIPTION, tr("Select objects for selected relation members"));

            putValue(SMALL_ICON, ImageProvider.get("dialogs/relation", "selectprimitives"));

            updateEnabledState();

        }

        protected void updateEnabledState() {

            setEnabled(memberTable.getSelectedRowCount() > 0);

        }

        @Override

        public void actionPerformed(ActionEvent e) {

            getLayer().data.setSelected(memberTableModel.getSelectedChildPrimitives());

        }

        @Override

        public void valueChanged(ListSelectionEvent e) {

            updateEnabledState();

        }

    }

    class SortAction extends AbstractAction implements TableModelListener {

        public SortAction() {

            String tooltip = tr("Sort the relation members");

            putValue(SMALL_ICON, ImageProvider.get("dialogs", "sort"));

            putValue(NAME, tr("Sort"));

            Shortcut sc = Shortcut.registerShortcut("relationeditor:sort", tr("Relation Editor: Sort"),

                KeyEvent.VK_END, Shortcut.ALT);

            sc.setAccelerator(this);

            putValue(SHORT_DESCRIPTION, Main.platform.makeTooltip(tooltip, sc));

            updateEnabledState();

        }

        @Override

        public void actionPerformed(ActionEvent e) {

            memberTableModel.sort();

        }

        protected void updateEnabledState() {

            setEnabled(memberTableModel.getRowCount() > 0);

        }

        @Override

        public void tableChanged(TableModelEvent e) {

            updateEnabledState();

        }

    }

    class ReverseAction extends AbstractAction implements TableModelListener {

        public ReverseAction() {

            putValue(SHORT_DESCRIPTION, tr("Reverse the order of the relation members"));

            putValue(SMALL_ICON, ImageProvider.get("dialogs/relation", "reverse"));

            putValue(NAME, tr("Reverse"));

        //  Shortcut.register Shortcut("relationeditor:reverse", tr("Relation Editor: Reverse"),

        //      KeyEvent.VK_END, Shortcut.ALT)

            updateEnabledState();

        }

        @Override

        public void actionPerformed(ActionEvent e) {

            memberTableModel.reverse();

        }

        protected void updateEnabledState() {

            setEnabled(memberTableModel.getRowCount() > 0);

        }

        @Override

        public void tableChanged(TableModelEvent e) {

            updateEnabledState();

        }

    }

    class MoveUpAction extends AbstractAction implements ListSelectionListener {

        public MoveUpAction() {

            String tooltip = tr("Move the currently selected members up");

            putValue(SMALL_ICON, ImageProvider.get("dialogs", "moveup"));

            Shortcut sc = Shortcut.registerShortcut("relationeditor:moveup", tr("Relation Editor: Move Up"),

                KeyEvent.VK_UP, Shortcut.ALT);

            sc.setAccelerator(this);

            putValue(SHORT_DESCRIPTION, Main.platform.makeTooltip(tooltip, sc));

            setEnabled(false);

        }

        @Override

        public void actionPerformed(ActionEvent e) {

            memberTableModel.moveUp(memberTable.getSelectedRows());

        }

        @Override

        public void valueChanged(ListSelectionEvent e) {

            setEnabled(memberTableModel.canMoveUp(memberTable.getSelectedRows()));

        }

    }

    class MoveDownAction extends AbstractAction implements ListSelectionListener {

        public MoveDownAction() {

            String tooltip = tr("Move the currently selected members down");

            putValue(SMALL_ICON, ImageProvider.get("dialogs", "movedown"));

            Shortcut sc = Shortcut.registerShortcut("relationeditor:movedown", tr("Relation Editor: Move Down"),

                KeyEvent.VK_DOWN, Shortcut.ALT);

            sc.setAccelerator(this);

            putValue(SHORT_DESCRIPTION, Main.platform.makeTooltip(tooltip, sc));

            setEnabled(false);

        }

        @Override

        public void actionPerformed(ActionEvent e) {

            memberTableModel.moveDown(memberTable.getSelectedRows());

        }

        @Override

        public void valueChanged(ListSelectionEvent e) {

            setEnabled(memberTableModel.canMoveDown(memberTable.getSelectedRows()));

        }

    }

    class RemoveAction extends AbstractAction implements ListSelectionListener {

        public RemoveAction() {

            String tooltip = tr("Remove the currently selected members from this relation");

            putValue(SMALL_ICON, ImageProvider.get("dialogs", "delete"));

            putValue(NAME, tr("Remove"));

            Shortcut sc = Shortcut.registerShortcut("relationeditor:remove", tr("Relation Editor: Remove"),