001// License: GPL. For details, see LICENSE file.
002package org.openstreetmap.josm.gui.dialogs.properties;
003
004import static org.openstreetmap.josm.actions.search.SearchAction.searchStateless;
005import static org.openstreetmap.josm.tools.I18n.tr;
006
007import java.awt.Component;
008import java.awt.Container;
009import java.awt.Font;
010import java.awt.GridBagConstraints;
011import java.awt.GridBagLayout;
012import java.awt.Point;
013import java.awt.event.ActionEvent;
014import java.awt.event.KeyEvent;
015import java.awt.event.MouseAdapter;
016import java.awt.event.MouseEvent;
017import java.beans.PropertyChangeEvent;
018import java.beans.PropertyChangeListener;
019import java.util.ArrayList;
020import java.util.Arrays;
021import java.util.Collection;
022import java.util.Collections;
023import java.util.EnumSet;
024import java.util.HashMap;
025import java.util.HashSet;
026import java.util.List;
027import java.util.Map;
028import java.util.Map.Entry;
029import java.util.Set;
030import java.util.TreeMap;
031import java.util.TreeSet;
032import java.util.concurrent.atomic.AtomicBoolean;
033import java.util.stream.Collectors;
034
035import javax.swing.AbstractAction;
036import javax.swing.JComponent;
037import javax.swing.JLabel;
038import javax.swing.JMenuItem;
039import javax.swing.JPanel;
040import javax.swing.JPopupMenu;
041import javax.swing.JScrollPane;
042import javax.swing.JTable;
043import javax.swing.KeyStroke;
044import javax.swing.ListSelectionModel;
045import javax.swing.event.ListSelectionEvent;
046import javax.swing.event.ListSelectionListener;
047import javax.swing.event.PopupMenuEvent;
048import javax.swing.event.RowSorterEvent;
049import javax.swing.event.RowSorterListener;
050import javax.swing.table.DefaultTableCellRenderer;
051import javax.swing.table.DefaultTableModel;
052import javax.swing.table.TableCellRenderer;
053import javax.swing.table.TableColumnModel;
054import javax.swing.table.TableModel;
055import javax.swing.table.TableRowSorter;
056
057import org.openstreetmap.josm.actions.JosmAction;
058import org.openstreetmap.josm.actions.relation.DeleteRelationsAction;
059import org.openstreetmap.josm.actions.relation.DuplicateRelationAction;
060import org.openstreetmap.josm.actions.relation.EditRelationAction;
061import org.openstreetmap.josm.command.ChangeMembersCommand;
062import org.openstreetmap.josm.command.ChangePropertyCommand;
063import org.openstreetmap.josm.command.Command;
064import org.openstreetmap.josm.data.UndoRedoHandler;
065import org.openstreetmap.josm.data.coor.LatLon;
066import org.openstreetmap.josm.data.osm.AbstractPrimitive;
067import org.openstreetmap.josm.data.osm.DataSelectionListener;
068import org.openstreetmap.josm.data.osm.DataSet;
069import org.openstreetmap.josm.data.osm.DefaultNameFormatter;
070import org.openstreetmap.josm.data.osm.IPrimitive;
071import org.openstreetmap.josm.data.osm.IRelation;
072import org.openstreetmap.josm.data.osm.IRelationMember;
073import org.openstreetmap.josm.data.osm.KeyValueVisitor;
074import org.openstreetmap.josm.data.osm.Node;
075import org.openstreetmap.josm.data.osm.OsmDataManager;
076import org.openstreetmap.josm.data.osm.OsmPrimitive;
077import org.openstreetmap.josm.data.osm.Relation;
078import org.openstreetmap.josm.data.osm.RelationMember;
079import org.openstreetmap.josm.data.osm.Tag;
080import org.openstreetmap.josm.data.osm.Tags;
081import org.openstreetmap.josm.data.osm.Way;
082import org.openstreetmap.josm.data.osm.event.AbstractDatasetChangedEvent;
083import org.openstreetmap.josm.data.osm.event.DataSetListenerAdapter;
084import org.openstreetmap.josm.data.osm.event.DatasetEventManager;
085import org.openstreetmap.josm.data.osm.event.DatasetEventManager.FireMode;
086import org.openstreetmap.josm.data.osm.event.SelectionEventManager;
087import org.openstreetmap.josm.data.osm.search.SearchCompiler;
088import org.openstreetmap.josm.data.osm.search.SearchSetting;
089import org.openstreetmap.josm.data.preferences.AbstractProperty.ValueChangeEvent;
090import org.openstreetmap.josm.data.preferences.AbstractProperty.ValueChangeListener;
091import org.openstreetmap.josm.data.preferences.BooleanProperty;
092import org.openstreetmap.josm.data.preferences.CachingProperty;
093import org.openstreetmap.josm.gui.ConditionalOptionPaneUtil;
094import org.openstreetmap.josm.gui.ExtendedDialog;
095import org.openstreetmap.josm.gui.MainApplication;
096import org.openstreetmap.josm.gui.PopupMenuHandler;
097import org.openstreetmap.josm.gui.PrimitiveHoverListener;
098import org.openstreetmap.josm.gui.SideButton;
099import org.openstreetmap.josm.gui.datatransfer.ClipboardUtils;
100import org.openstreetmap.josm.gui.dialogs.ToggleDialog;
101import org.openstreetmap.josm.gui.dialogs.relation.RelationEditor;
102import org.openstreetmap.josm.gui.dialogs.relation.RelationPopupMenus;
103import org.openstreetmap.josm.gui.help.HelpUtil;
104import org.openstreetmap.josm.gui.layer.Layer;
105import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeEvent;
106import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeListener;
107import org.openstreetmap.josm.gui.layer.OsmDataLayer;
108import org.openstreetmap.josm.gui.tagging.presets.TaggingPreset;
109import org.openstreetmap.josm.gui.tagging.presets.TaggingPresetHandler;
110import org.openstreetmap.josm.gui.tagging.presets.TaggingPresetListener;
111import org.openstreetmap.josm.gui.tagging.presets.TaggingPresetType;
112import org.openstreetmap.josm.gui.tagging.presets.TaggingPresets;
113import org.openstreetmap.josm.gui.tagging.presets.items.KeyedItem;
114import org.openstreetmap.josm.gui.util.AbstractTag2LinkPopupListener;
115import org.openstreetmap.josm.gui.util.HighlightHelper;
116import org.openstreetmap.josm.gui.util.TableHelper;
117import org.openstreetmap.josm.gui.widgets.CompileSearchTextDecorator;
118import org.openstreetmap.josm.gui.widgets.DisableShortcutsOnFocusGainedTextField;
119import org.openstreetmap.josm.gui.widgets.FilterField;
120import org.openstreetmap.josm.gui.widgets.JosmTextField;
121import org.openstreetmap.josm.gui.widgets.PopupMenuLauncher;
122import org.openstreetmap.josm.spi.preferences.Config;
123import org.openstreetmap.josm.spi.preferences.PreferenceChangeEvent;
124import org.openstreetmap.josm.tools.AlphanumComparator;
125import org.openstreetmap.josm.tools.GBC;
126import org.openstreetmap.josm.tools.ImageProvider;
127import org.openstreetmap.josm.tools.InputMapUtils;
128import org.openstreetmap.josm.tools.Logging;
129import org.openstreetmap.josm.tools.Shortcut;
130import org.openstreetmap.josm.tools.TaginfoRegionalInstance;
131import org.openstreetmap.josm.tools.Territories;
132import org.openstreetmap.josm.tools.Utils;
133
134/**
135 * This dialog displays the tags of the current selected primitives.
136 *
137 * If no object is selected, the dialog list is empty.
138 * If only one is selected, all tags of this object are selected.
139 * If more than one object is selected, the sum of all tags is displayed. If the
140 * different objects share the same tag, the shared value is displayed. If they have
141 * different values, all of them are put in a combo box and the string "<different>"
142 * is displayed in italic.
143 *
144 * Below the list, the user can click on an add, modify and delete tag button to
145 * edit the table selection value.
146 *
147 * The command is applied to all selected entries.
148 *
149 * @author imi
150 */
151public class PropertiesDialog extends ToggleDialog
152implements DataSelectionListener, ActiveLayerChangeListener, PropertyChangeListener, 
153        DataSetListenerAdapter.Listener, TaggingPresetListener, PrimitiveHoverListener {
154    private static final BooleanProperty PROP_DISPLAY_DISCARDABLE_KEYS = new BooleanProperty("display.discardable-keys", false);
155
156    /**
157     * hook for roadsigns plugin to display a small button in the upper right corner of this dialog
158     */
159    public static final JPanel pluginHook = new JPanel();
160
161    /**
162     * The tag data of selected objects.
163     */
164    private final ReadOnlyTableModel tagData = new ReadOnlyTableModel();
165    private final PropertiesCellRenderer cellRenderer = new PropertiesCellRenderer();
166    private final transient TableRowSorter<ReadOnlyTableModel> tagRowSorter = new TableRowSorter<>(tagData);
167    private final JosmTextField tagTableFilter;
168
169    /**
170     * The membership data of selected objects.
171     */
172    private final DefaultTableModel membershipData = new ReadOnlyTableModel();
173
174    /**
175     * The tags table.
176     */
177    private final JTable tagTable = new JTable(tagData);
178
179    /**
180     * The membership table.
181     */
182    private final JTable membershipTable = new JTable(membershipData);
183
184    /** JPanel containing both previous tables */
185    private final JPanel bothTables = new JPanel(new GridBagLayout());
186
187    // Popup menus
188    private final JPopupMenu tagMenu = new JPopupMenu();
189    private final JPopupMenu membershipMenu = new JPopupMenu();
190    private final JPopupMenu blankSpaceMenu = new JPopupMenu();
191
192    // Popup menu handlers
193    private final transient PopupMenuHandler tagMenuHandler = new PopupMenuHandler(tagMenu);
194    private final transient PopupMenuHandler membershipMenuHandler = new PopupMenuHandler(membershipMenu);
195    private final transient PopupMenuHandler blankSpaceMenuHandler = new PopupMenuHandler(blankSpaceMenu);
196
197    private final List<JMenuItem> tagMenuTagInfoNatItems = new ArrayList<>();
198    private final List<JMenuItem> membershipMenuTagInfoNatItems = new ArrayList<>();
199
200    private final transient Map<String, Map<String, Integer>> valueCount = new TreeMap<>();
201    /**
202     * This sub-object is responsible for all adding and editing of tags
203     */
204    private final transient TagEditHelper editHelper = new TagEditHelper(tagTable, tagData, valueCount);
205
206    private final transient DataSetListenerAdapter dataChangedAdapter = new DataSetListenerAdapter(this);
207    private final HelpAction helpTagAction = new HelpTagAction(tagTable, editHelper::getDataKey, editHelper::getDataValues);
208    private final HelpAction helpRelAction = new HelpMembershipAction(membershipTable, x -> (IRelation<?>) membershipData.getValueAt(x, 0));
209    private final TaginfoAction taginfoAction = new TaginfoAction(
210            tagTable, editHelper::getDataKey, editHelper::getDataValues,
211            membershipTable, x -> (IRelation<?>) membershipData.getValueAt(x, 0));
212    private final TaginfoAction tagHistoryAction = taginfoAction.toTagHistoryAction();
213    private final Collection<TaginfoAction> taginfoNationalActions = new ArrayList<>();
214    private transient int taginfoNationalHash;
215    private final PasteValueAction pasteValueAction = new PasteValueAction();
216    private final CopyValueAction copyValueAction = new CopyValueAction(
217            tagTable, editHelper::getDataKey, OsmDataManager.getInstance()::getInProgressISelection);
218    private final CopyKeyValueAction copyKeyValueAction = new CopyKeyValueAction(
219            tagTable, editHelper::getDataKey, OsmDataManager.getInstance()::getInProgressISelection);
220    private final CopyAllKeyValueAction copyAllKeyValueAction = new CopyAllKeyValueAction(
221            tagTable, editHelper::getDataKey, OsmDataManager.getInstance()::getInProgressISelection).registerShortcut(); /* NO-SHORTCUT */
222    private final SearchAction searchActionSame = new SearchAction(true);
223    private final SearchAction searchActionAny = new SearchAction(false);
224    private final AddAction addAction = new AddAction();
225    private final EditAction editAction = new EditAction();
226    private final DeleteAction deleteAction = new DeleteAction();
227    private final JosmAction[] josmActions = {addAction, editAction, deleteAction};
228
229    private final transient HighlightHelper highlightHelper = new HighlightHelper();
230
231    /**
232     * The Add button (needed to be able to disable it)
233     */
234    private final SideButton btnAdd = new SideButton(addAction);
235    /**
236     * The Edit button (needed to be able to disable it)
237     */
238    private final SideButton btnEdit = new SideButton(editAction);
239    /**
240     * The Delete button (needed to be able to disable it)
241     */
242    private final SideButton btnDel = new SideButton(deleteAction);
243    /**
244     * Matching preset display class
245     */
246    private final PresetListPanel presets = new PresetListPanel();
247
248    /**
249     * Text to display when nothing selected.
250     */
251    private final JLabel selectSth = new JLabel("<html><p>"
252            + tr("Select objects for which to change tags.") + "</p></html>");
253
254    private final transient TaggingPresetHandler presetHandler = new TaggingPresetCommandHandler();
255
256    private PopupMenuLauncher popupMenuLauncher;
257
258    private static final BooleanProperty PROP_AUTORESIZE_TAGS_TABLE = new BooleanProperty("propertiesdialog.autoresizeTagsTable", false);
259
260    /**
261     * Show tags and relation memberships of objects in the properties dialog when hovering over them with the mouse pointer
262     * @since 18574
263     */
264    public static final BooleanProperty PROP_PREVIEW_ON_HOVER = new BooleanProperty("propertiesdialog.preview-on-hover", true);
265    private final HoverPreviewPropListener hoverPreviewPropListener = new HoverPreviewPropListener();
266
267    /**
268     * Always show information for selected objects when something is selected instead of the hovered object
269     * @since 18574
270     */
271    public static final CachingProperty<Boolean> PROP_PREVIEW_ON_HOVER_PRIORITIZE_SELECTION = 
272        new BooleanProperty("propertiesdialog.preview-on-hover.always-show-selected", true).cached();
273    private final HoverPreviewPreferSelectionPropListener hoverPreviewPrioritizeSelectionPropListener = 
274        new HoverPreviewPreferSelectionPropListener();
275
276    /**
277     * Create a new PropertiesDialog
278     */
279    public PropertiesDialog() {
280        super(tr("Tags/Memberships"), "propertiesdialog", tr("Tags for selected objects."),
281                Shortcut.registerShortcut("subwindow:properties", tr("Windows: {0}", tr("Tags/Memberships")), KeyEvent.VK_P,
282                        Shortcut.ALT_SHIFT), 150, true);
283
284        setupTagsMenu();
285        buildTagsTable();
286
287        setupMembershipMenu();
288        buildMembershipTable();
289
290        tagTableFilter = setupFilter();
291
292        // combine both tables and wrap them in a scrollPane
293        boolean top = Config.getPref().getBoolean("properties.presets.top", true);
294        boolean presetsVisible = Config.getPref().getBoolean("properties.presets.visible", true);
295        if (presetsVisible && top) {
296            bothTables.add(presets, GBC.std().fill(GridBagConstraints.HORIZONTAL).insets(5, 2, 5, 2).anchor(GridBagConstraints.NORTHWEST));
297            double epsilon = Double.MIN_VALUE; // need to set a weight or else anchor value is ignored
298            bothTables.add(pluginHook, GBC.eol().insets(0, 1, 1, 1).anchor(GridBagConstraints.NORTHEAST).weight(epsilon, epsilon));
299        }
300        bothTables.add(selectSth, GBC.eol().fill().insets(10, 10, 10, 10));
301        bothTables.add(tagTableFilter, GBC.eol().fill(GridBagConstraints.HORIZONTAL));
302        bothTables.add(tagTable.getTableHeader(), GBC.eol().fill(GridBagConstraints.HORIZONTAL));
303        bothTables.add(tagTable, GBC.eol().fill(GridBagConstraints.BOTH));
304        bothTables.add(membershipTable.getTableHeader(), GBC.eol().fill(GridBagConstraints.HORIZONTAL));
305        bothTables.add(membershipTable, GBC.eol().fill(GridBagConstraints.BOTH));
306        if (presetsVisible && !top) {
307            bothTables.add(presets, GBC.eol().fill(GridBagConstraints.HORIZONTAL).insets(5, 2, 5, 2));
308        }
309
310        setupBlankSpaceMenu();
311        setupKeyboardShortcuts();
312
313        // Let the actions know when selection in the tables change
314        tagTable.getSelectionModel().addListSelectionListener(editAction);
315        membershipTable.getSelectionModel().addListSelectionListener(editAction);
316        tagTable.getSelectionModel().addListSelectionListener(deleteAction);
317        membershipTable.getSelectionModel().addListSelectionListener(deleteAction);
318
319        JScrollPane scrollPane = (JScrollPane) createLayout(bothTables, true,
320                Arrays.asList(this.btnAdd, this.btnEdit, this.btnDel));
321
322        MouseClickWatch mouseClickWatch = new MouseClickWatch();
323        tagTable.addMouseListener(mouseClickWatch);
324        membershipTable.addMouseListener(mouseClickWatch);
325        scrollPane.addMouseListener(mouseClickWatch);
326
327        selectSth.setPreferredSize(scrollPane.getSize());
328        presets.setSize(scrollPane.getSize());
329
330        editHelper.loadTagsIfNeeded();
331
332        TaggingPresets.addListener(this);
333
334        PROP_PREVIEW_ON_HOVER.addListener(hoverPreviewPropListener);
335        PROP_PREVIEW_ON_HOVER_PRIORITIZE_SELECTION.addListener(hoverPreviewPrioritizeSelectionPropListener);
336    }
337
338    @Override
339    public String helpTopic() {
340        return HelpUtil.ht("/Dialog/TagsMembership");
341    }
342
343    private void buildTagsTable() {
344        // setting up the tags table
345        TableHelper.setFont(tagTable, getClass());
346        tagData.setColumnIdentifiers(new String[]{tr("Key"), tr("Value")});
347        tagTable.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
348        tagTable.getTableHeader().setReorderingAllowed(false);
349
350        tagTable.getColumnModel().getColumn(0).setCellRenderer(cellRenderer);
351        tagTable.getColumnModel().getColumn(1).setCellRenderer(cellRenderer);
352        tagTable.setRowSorter(tagRowSorter);
353
354        final RemoveHiddenSelection removeHiddenSelection = new RemoveHiddenSelection();
355        tagTable.getSelectionModel().addListSelectionListener(removeHiddenSelection);
356        tagRowSorter.addRowSorterListener(removeHiddenSelection);
357        tagRowSorter.setComparator(0, AlphanumComparator.getInstance());
358        tagRowSorter.setComparator(1, (o1, o2) -> {
359            if (o1 instanceof Map && o2 instanceof Map) {
360                final String v1 = ((Map) o1).size() == 1 ? (String) ((Map) o1).keySet().iterator().next() : KeyedItem.DIFFERENT_I18N;
361                final String v2 = ((Map) o2).size() == 1 ? (String) ((Map) o2).keySet().iterator().next() : KeyedItem.DIFFERENT_I18N;
362                return AlphanumComparator.getInstance().compare(v1, v2);
363            } else {
364                return AlphanumComparator.getInstance().compare(String.valueOf(o1), String.valueOf(o2));
365            }
366        });
367    }
368
369    private void buildMembershipTable() {
370        TableHelper.setFont(membershipTable, getClass());
371        membershipData.setColumnIdentifiers(new String[]{tr("Member Of"), tr("Role"), tr("Position")});
372        membershipTable.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
373
374        TableColumnModel mod = membershipTable.getColumnModel();
375        membershipTable.getTableHeader().setReorderingAllowed(false);
376        mod.getColumn(0).setCellRenderer(new MemberOfCellRenderer());
377        mod.getColumn(1).setCellRenderer(new RoleCellRenderer());
378        mod.getColumn(2).setCellRenderer(new PositionCellRenderer());
379        mod.getColumn(2).setPreferredWidth(20);
380        mod.getColumn(1).setPreferredWidth(40);
381        mod.getColumn(0).setPreferredWidth(200);
382    }
383
384    /**
385     * Creates the popup menu @field blankSpaceMenu and its launcher on main panel.
386     */
387    private void setupBlankSpaceMenu() {
388        if (Config.getPref().getBoolean("properties.menu.add_edit_delete", true)) {
389            blankSpaceMenuHandler.addAction(addAction);
390            PopupMenuLauncher launcher = new BlankSpaceMenuLauncher(blankSpaceMenu);
391            bothTables.addMouseListener(launcher);
392            tagTable.addMouseListener(launcher);
393        }
394    }
395
396    private void destroyTaginfoNationalActions() {
397        membershipMenuTagInfoNatItems.forEach(membershipMenu::remove);
398        membershipMenuTagInfoNatItems.clear();
399        tagMenuTagInfoNatItems.forEach(tagMenu::remove);
400        tagMenuTagInfoNatItems.clear();
401        taginfoNationalActions.clear();
402    }
403
404    private void setupTaginfoNationalActions(Collection<? extends IPrimitive> newSel) {
405        if (newSel.isEmpty()) {
406            return;
407        }
408        final LatLon center = newSel.iterator().next().getBBox().getCenter();
409        List<TaginfoRegionalInstance> regionalInstances = Territories.getRegionalTaginfoUrls(center);
410        int newHashCode = regionalInstances.hashCode();
411        if (newHashCode == taginfoNationalHash) {
412            // taginfoNationalActions are still valid
413            return;
414        }
415        taginfoNationalHash = newHashCode;
416        destroyTaginfoNationalActions();
417        regionalInstances.stream()
418                .map(taginfo -> taginfoAction.withTaginfoUrl(tr("Go to Taginfo ({0})", taginfo.toString()), taginfo.getUrl()))
419                .forEach(taginfoNationalActions::add);
420        taginfoNationalActions.stream().map(membershipMenu::add).forEach(membershipMenuTagInfoNatItems::add);
421        taginfoNationalActions.stream().map(tagMenu::add).forEach(tagMenuTagInfoNatItems::add);
422    }
423
424    /**
425     * Creates the popup menu @field membershipMenu and its launcher on membership table.
426     */
427    private void setupMembershipMenu() {
428        // setting up the membership table
429        if (Config.getPref().getBoolean("properties.menu.add_edit_delete", true)) {
430            membershipMenuHandler.addAction(editAction);
431            membershipMenuHandler.addAction(deleteAction);
432            membershipMenu.addSeparator();
433        }
434        RelationPopupMenus.setupHandler(membershipMenuHandler,
435                EditRelationAction.class, DuplicateRelationAction.class, DeleteRelationsAction.class);
436        membershipMenu.addSeparator();
437        membershipMenu.add(helpRelAction);
438        membershipMenu.add(taginfoAction);
439
440        membershipMenu.addPopupMenuListener(new AbstractTag2LinkPopupListener() {
441            @Override
442            public void popupMenuWillBecomeVisible(PopupMenuEvent e) {
443                getSelectedMembershipRelations().forEach(relation ->
444                        relation.visitKeys((primitive, key, value) -> addLinks(membershipMenu, key, value)));
445            }
446        });
447
448        popupMenuLauncher = new PopupMenuLauncher(membershipMenu) {
449            @Override
450            protected int checkTableSelection(JTable table, Point p) {
451                int row = super.checkTableSelection(table, p);
452                List<IRelation<?>> rels = Arrays.stream(table.getSelectedRows())
453                        .mapToObj(i -> (IRelation<?>) table.getValueAt(i, 0))
454                        .collect(Collectors.toList());
455                membershipMenuHandler.setPrimitives(rels);
456                return row;
457            }
458
459            @Override
460            public void mouseClicked(MouseEvent e) {
461                //update highlights
462                if (MainApplication.isDisplayingMapView()) {
463                    int row = membershipTable.rowAtPoint(e.getPoint());
464                    if (row >= 0 && highlightHelper.highlightOnly((Relation) membershipTable.getValueAt(row, 0))) {
465                        MainApplication.getMap().mapView.repaint();
466                    }
467                }
468                super.mouseClicked(e);
469            }
470
471            @Override
472            public void mouseExited(MouseEvent me) {
473                highlightHelper.clear();
474            }
475        };
476        membershipTable.addMouseListener(popupMenuLauncher);
477    }
478
479    /**
480     * Creates the popup menu @field tagMenu and its launcher on tag table.
481     */
482    private void setupTagsMenu() {
483        if (Config.getPref().getBoolean("properties.menu.add_edit_delete", true)) {
484            tagMenu.add(addAction);
485            tagMenu.add(editAction);
486            tagMenu.add(deleteAction);
487            tagMenu.addSeparator();
488        }
489        tagMenu.add(pasteValueAction);
490        tagMenu.add(copyValueAction);
491        tagMenu.add(copyKeyValueAction);
492        tagMenu.addPopupMenuListener(copyKeyValueAction);
493        tagMenu.add(copyAllKeyValueAction);
494        tagMenu.addSeparator();
495        tagMenu.add(searchActionAny);
496        tagMenu.add(searchActionSame);
497        tagMenu.addSeparator();
498        tagMenu.add(helpTagAction);
499        tagMenu.add(tagHistoryAction);
500        tagMenu.add(taginfoAction);
501        tagMenu.addPopupMenuListener(new AbstractTag2LinkPopupListener() {
502            @Override
503            public void popupMenuWillBecomeVisible(PopupMenuEvent e) {
504                visitSelectedProperties((primitive, key, value) -> addLinks(tagMenu, key, value));
505            }
506        });
507
508        tagTable.addMouseListener(new PopupMenuLauncher(tagMenu));
509    }
510
511    /**
512     * Sets a filter to restrict the displayed properties.
513     * @param filter the filter
514     * @since 8980
515     */
516    public void setFilter(final SearchCompiler.Match filter) {
517        this.tagRowSorter.setRowFilter(new SearchBasedRowFilter(filter));
518    }
519
520    /**
521     * Assigns all needed keys like Enter and Spacebar to most important actions.
522     */
523    private void setupKeyboardShortcuts() {
524
525        // ENTER = editAction, open "edit" dialog
526        InputMapUtils.addEnterActionWhenAncestor(tagTable, editAction);
527        InputMapUtils.addEnterActionWhenAncestor(membershipTable, editAction);
528
529        // INSERT button = addAction, open "add tag" dialog
530        tagTable.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT)
531                .put(KeyStroke.getKeyStroke(KeyEvent.VK_INSERT, 0), "onTableInsert");
532        tagTable.getActionMap().put("onTableInsert", addAction);
533
534        // unassign some standard shortcuts for JTable to allow upload / download / image browsing
535        InputMapUtils.unassignCtrlShiftUpDown(tagTable, JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
536        InputMapUtils.unassignPageUpDown(tagTable, JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
537
538        // unassign some standard shortcuts for correct copy-pasting, fix #8508
539        tagTable.setTransferHandler(null);
540
541        tagTable.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT)
542                .put(Shortcut.getCopyKeyStroke(), "onCopy");
543        tagTable.getActionMap().put("onCopy", copyKeyValueAction);
544
545        // allow using enter to add tags for all look&feel configurations
546        InputMapUtils.enableEnter(this.btnAdd);
547
548        // DEL button = deleteAction
549        getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(
550                KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0), "delete"
551                );
552        getActionMap().put("delete", deleteAction);
553
554        // F1 button = custom help action
555        getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(
556                HelpAction.getKeyStroke(), "onHelp");
557        getActionMap().put("onHelp", new AbstractAction() {
558            @Override
559            public void actionPerformed(ActionEvent e) {
560                if (membershipTable.getSelectedRowCount() == 1) {
561                    helpRelAction.actionPerformed(e);
562                } else {
563                    helpTagAction.actionPerformed(e);
564                }
565            }
566        });
567    }
568
569    private JosmTextField setupFilter() {
570        final JosmTextField f = new DisableShortcutsOnFocusGainedTextField();
571        FilterField.setSearchIcon(f);
572        f.setToolTipText(tr("Tag filter"));
573        final CompileSearchTextDecorator decorator = CompileSearchTextDecorator.decorate(f);
574        f.addPropertyChangeListener("filter", evt -> setFilter(decorator.getMatch()));
575        return f;
576    }
577
578    /**
579     * This simply fires up an {@link RelationEditor} for the relation shown; everything else
580     * is the editor's business.
581     *
582     * @param row position
583     */
584    private void editMembership(int row) {
585        Relation relation = (Relation) membershipData.getValueAt(row, 0);
586        MainApplication.getMap().relationListDialog.selectRelation(relation);
587        OsmDataLayer layer = MainApplication.getLayerManager().getActiveDataLayer();
588        if (!layer.isLocked()) {
589            List<RelationMember> members = ((MemberInfo) membershipData.getValueAt(row, 1)).role.stream()
590                    .filter(RelationMember.class::isInstance)
591                    .map(RelationMember.class::cast)
592                    .collect(Collectors.toList());
593            RelationEditor.getEditor(layer, relation, members).setVisible(true);
594        }
595    }
596
597    private static int findViewRow(JTable table, TableModel model, Object value) {
598        for (int i = 0; i < model.getRowCount(); i++) {
599            if (model.getValueAt(i, 0).equals(value))
600                return table.convertRowIndexToView(i);
601        }
602        return -1;
603    }
604
605    /**
606     * Update selection status, call {@link #selectionChanged} function.
607     */
608    private void updateSelection() {
609        // Parameter is ignored in this class
610        selectionChanged(null);
611    }
612
613    @Override
614    public void showNotify() {
615        DatasetEventManager.getInstance().addDatasetListener(dataChangedAdapter, FireMode.IN_EDT_CONSOLIDATED);
616        SelectionEventManager.getInstance().addSelectionListenerForEdt(this);
617        MainApplication.getLayerManager().addActiveLayerChangeListener(this);
618        if (Boolean.TRUE.equals(PROP_PREVIEW_ON_HOVER.get()))
619            MainApplication.getMap().mapView.addPrimitiveHoverListener(this);
620        for (JosmAction action : josmActions) {
621            MainApplication.registerActionShortcut(action);
622        }
623        updateSelection();
624    }
625
626    @Override
627    public void hideNotify() {
628        DatasetEventManager.getInstance().removeDatasetListener(dataChangedAdapter);
629        SelectionEventManager.getInstance().removeSelectionListener(this);
630        MainApplication.getLayerManager().removeActiveLayerChangeListener(this);
631        MainApplication.getMap().mapView.removePrimitiveHoverListener(this);
632        for (JosmAction action : josmActions) {
633            MainApplication.unregisterActionShortcut(action);
634        }
635    }
636
637    @Override
638    public void setVisible(boolean b) {
639        super.setVisible(b);
640        if (b && MainApplication.getLayerManager().getActiveData() != null) {
641            updateSelection();
642        }
643    }
644
645    @Override
646    public void destroy() {
647        membershipMenuHandler.setPrimitives(Collections.emptyList());
648        destroyTaginfoNationalActions();
649        membershipTable.removeMouseListener(popupMenuLauncher);
650        super.destroy();
651        TaggingPresets.removeListener(this);
652        PROP_PREVIEW_ON_HOVER.removeListener(hoverPreviewPropListener);
653        PROP_PREVIEW_ON_HOVER_PRIORITIZE_SELECTION.removeListener(hoverPreviewPrioritizeSelectionPropListener);
654        Container parent = pluginHook.getParent();
655        if (parent != null) {
656            parent.remove(pluginHook);
657        }
658    }
659
660    @Override
661    public void selectionChanged(SelectionChangeEvent event) {
662        if (!isVisible())
663            return;
664        if (tagTable == null)
665            return; // selection changed may be received in base class constructor before init
666        if (tagTable.getCellEditor() != null) {
667            tagTable.getCellEditor().cancelCellEditing();
668        }
669
670        // Ignore parameter as we do not want to operate always on real selection here, especially in draw mode
671        Collection<? extends IPrimitive> newSel = OsmDataManager.getInstance().getInProgressISelection();
672
673        // Temporarily disable listening to primitive mouse hover events while we have a selection as that takes priority
674        if (Boolean.TRUE.equals(PROP_PREVIEW_ON_HOVER.get())) {
675            if (newSel.isEmpty()) {
676                MainApplication.getMap().mapView.addPrimitiveHoverListener(this);
677            } else if (Boolean.TRUE.equals(PROP_PREVIEW_ON_HOVER_PRIORITIZE_SELECTION.get())) {
678                MainApplication.getMap().mapView.removePrimitiveHoverListener(this);
679            }
680        }
681
682        updateUi(newSel);
683    }
684
685    @Override
686    public void primitiveHovered(PrimitiveHoverEvent e) {
687        Collection<? extends IPrimitive> selection = OsmDataManager.getInstance().getInProgressISelection();
688        if (Boolean.TRUE.equals(PROP_PREVIEW_ON_HOVER_PRIORITIZE_SELECTION.get()) && !selection.isEmpty())
689            return;
690
691        if (e.getHoveredPrimitive() != null) {
692            updateUi(e.getHoveredPrimitive());
693        } else {
694            updateUi(selection);
695        }
696    }
697
698    private void autoresizeTagTable() {
699        if (Boolean.TRUE.equals(PROP_AUTORESIZE_TAGS_TABLE.get())) {
700            // resize table's columns to fit content
701            TableHelper.computeColumnsWidth(tagTable);
702        }
703    }
704
705    private void updateUi(IPrimitive primitive) {
706        updateUi(primitive == null ? Collections.emptyList() :
707                                     Collections.singletonList(primitive));
708    }
709
710    private void updateUi(Collection<? extends IPrimitive> primitives) {
711        IRelation<?> selectedRelation = null;
712        String selectedTag = editHelper.getChangedKey(); // select last added or last edited key by default
713        if (selectedTag == null && tagTable.getSelectedRowCount() == 1) {
714            selectedTag = editHelper.getDataKey(tagTable.getSelectedRow());
715        }
716        if (membershipTable.getSelectedRowCount() == 1) {
717            selectedRelation = (IRelation<?>) membershipData.getValueAt(membershipTable.getSelectedRow(), 0);
718        }
719
720        updateTagTableData(primitives);
721        updateMembershipTableData(primitives);
722
723        updateMembershipTableVisibility();
724        updateActionsEnabledState();
725        updateTagTableVisibility(primitives);
726
727        setupTaginfoNationalActions(primitives);
728        autoresizeTagTable();
729
730        int selectedIndex;
731        if (selectedTag != null && (selectedIndex = findViewRow(tagTable, tagData, selectedTag)) != -1) {
732            tagTable.changeSelection(selectedIndex, 0, false, false);
733        } else if (selectedRelation != null && (selectedIndex = findViewRow(membershipTable, membershipData, selectedRelation)) != -1) {
734            membershipTable.changeSelection(selectedIndex, 0, false, false);
735        } else if (tagData.getRowCount() > 0) {
736            tagTable.changeSelection(0, 0, false, false);
737        } else if (membershipData.getRowCount() > 0) {
738            membershipTable.changeSelection(0, 0, false, false);
739        }
740
741        updateTitle(primitives);
742    }
743
744    private void updateTagTableData(Collection<? extends IPrimitive> primitives) {
745        int newSelSize = primitives.size();
746
747        // re-load tag data
748        tagData.setRowCount(0);
749
750        final boolean displayDiscardableKeys = PROP_DISPLAY_DISCARDABLE_KEYS.get();
751        final Map<String, Integer> keyCount = new HashMap<>();
752        final Map<String, String> tags = new HashMap<>();
753        valueCount.clear();
754        Set<TaggingPresetType> types = EnumSet.noneOf(TaggingPresetType.class);
755        for (IPrimitive osm : primitives) {
756            types.add(TaggingPresetType.forPrimitive(osm));
757            osm.visitKeys((p, key, value) -> {
758                if (displayDiscardableKeys || !AbstractPrimitive.getDiscardableKeys().contains(key)) {
759                    keyCount.put(key, keyCount.containsKey(key) ? keyCount.get(key) + 1 : 1);
760                    if (valueCount.containsKey(key)) {
761                        Map<String, Integer> v = valueCount.get(key);
762                        v.put(value, v.containsKey(value) ? v.get(value) + 1 : 1);
763                    } else {
764                        Map<String, Integer> v = new TreeMap<>();
765                        v.put(value, 1);
766                        valueCount.put(key, v);
767                    }
768                }
769            });
770        }
771        for (Entry<String, Map<String, Integer>> e : valueCount.entrySet()) {
772            int count = e.getValue().values().stream().mapToInt(i -> i).sum();
773            if (count < newSelSize) {
774                e.getValue().put("", newSelSize - count);
775            }
776            tagData.addRow(new Object[]{e.getKey(), e.getValue()});
777            tags.put(e.getKey(), e.getValue().size() == 1
778                    ? e.getValue().keySet().iterator().next() : KeyedItem.DIFFERENT_I18N);
779        }
780
781        presets.updatePresets(types, tags, presetHandler);
782    }
783
784    private void updateMembershipTableData(Collection<? extends IPrimitive> primitives) {
785        membershipData.setRowCount(0);
786
787        Map<IRelation<?>, MemberInfo> roles = new HashMap<>();
788        for (IPrimitive primitive : primitives) {
789            for (IPrimitive ref : primitive.getReferrers(true)) {
790                if (ref instanceof IRelation && !ref.isIncomplete() && !ref.isDeleted()) {
791                    IRelation<?> r = (IRelation<?>) ref;
792                    MemberInfo mi = roles.computeIfAbsent(r, ignore -> new MemberInfo(primitives));
793                    int i = 1;
794                    for (IRelationMember<?> m : r.getMembers()) {
795                        if (m.getMember() == primitive) {
796                            mi.add(m, i);
797                        }
798                        ++i;
799                    }
800                }
801            }
802        }
803
804        List<IRelation<?>> sortedRelations = new ArrayList<>(roles.keySet());
805        sortedRelations.sort((o1, o2) -> {
806            int comp = Boolean.compare(o1.isDisabledAndHidden(), o2.isDisabledAndHidden());
807            return comp != 0 ? comp : DefaultNameFormatter.getInstance().getRelationComparator().compare(o1, o2);
808        });
809
810        for (IRelation<?> r: sortedRelations) {
811            membershipData.addRow(new Object[]{r, roles.get(r)});
812        }
813    }
814
815    private void updateMembershipTableVisibility() {
816        membershipTable.getTableHeader().setVisible(membershipData.getRowCount() > 0);
817        membershipTable.setVisible(membershipData.getRowCount() > 0);
818    }
819
820    private void updateTagTableVisibility(Collection<? extends IPrimitive> primitives) {
821        boolean hasSelection = !primitives.isEmpty();
822        boolean hasTags = hasSelection && tagData.getRowCount() > 0;
823
824        tagTable.setVisible(hasTags);
825        tagTable.getTableHeader().setVisible(hasTags);
826        boolean filterVisible = Config.getPref().getBoolean("properties.filter.visible", true);
827        tagTableFilter.setVisible(hasTags && filterVisible);
828        selectSth.setVisible(!hasSelection);
829        pluginHook.setVisible(hasSelection);
830    }
831
832    private void updateActionsEnabledState() {
833        addAction.updateEnabledState();
834        editAction.updateEnabledState();
835        deleteAction.updateEnabledState();
836    }
837
838    private void updateTitle(Collection<? extends IPrimitive> primitives) {
839        int newSelSize = primitives.size();
840        if (tagData.getRowCount() != 0 || membershipData.getRowCount() != 0) {
841            if (newSelSize > 1) {
842                setTitle(tr("Objects: {2} / Tags: {0} / Memberships: {1}",
843                    tagData.getRowCount(), membershipData.getRowCount(), newSelSize));
844            } else {
845                setTitle(tr("Tags: {0} / Memberships: {1}",
846                    tagData.getRowCount(), membershipData.getRowCount()));
847            }
848        } else {
849            setTitle(tr("Tags/Memberships"));
850        }
851    }
852
853    /* ---------------------------------------------------------------------------------- */
854    /* PreferenceChangedListener                                                          */
855    /* ---------------------------------------------------------------------------------- */
856
857    /**
858     * Reloads data when the {@code display.discardable-keys} preference changes
859     */
860    @Override
861    public void preferenceChanged(PreferenceChangeEvent e) {
862        super.preferenceChanged(e);
863        if (PROP_DISPLAY_DISCARDABLE_KEYS.getKey().equals(e.getKey()) && MainApplication.getLayerManager().getActiveData() != null) {
864            updateSelection();
865        }
866    }
867
868    /* ---------------------------------------------------------------------------------- */
869    /* TaggingPresetListener                                                              */
870    /* ---------------------------------------------------------------------------------- */
871
872    /**
873     * Updates the preset list when Presets preference changes.
874     */
875    @Override
876    public void taggingPresetsModified() {
877        if (MainApplication.getLayerManager().getActiveData() != null) {
878            updateSelection();
879        }
880    }
881
882    /* ---------------------------------------------------------------------------------- */
883    /* ActiveLayerChangeListener                                                          */
884    /* ---------------------------------------------------------------------------------- */
885    @Override
886    public void activeOrEditLayerChanged(ActiveLayerChangeEvent e) {
887        if (e.getSource().getEditLayer() == null) {
888            editHelper.saveTagsIfNeeded();
889            editHelper.resetSelection();
890        }
891        // it is time to save history of tags
892        updateSelection();
893
894        // Listen for active layer visibility change to enable/disable hover preview
895        // Remove previous listener first (order matters if we are somehow getting a layer change event 
896        // switching from one layer to the same layer)
897        Layer prevLayer = e.getPreviousDataLayer();
898        if (prevLayer != null) {
899            prevLayer.removePropertyChangeListener(this);
900        }
901
902        Layer newLayer = e.getSource().getActiveDataLayer();
903        if (newLayer != null) {
904            newLayer.addPropertyChangeListener(this);
905            if (newLayer.isVisible() && Boolean.TRUE.equals(PROP_PREVIEW_ON_HOVER.get())) {
906                MainApplication.getMap().mapView.addPrimitiveHoverListener(this);
907            } else {
908                MainApplication.getMap().mapView.removePrimitiveHoverListener(this);
909            }
910        }
911    }
912
913    @Override
914    public void propertyChange(PropertyChangeEvent e) {
915        if (Layer.VISIBLE_PROP.equals(e.getPropertyName())) {
916            boolean isVisible = (boolean) e.getNewValue();
917
918            // Disable hover preview when primitives are invisible
919            if (isVisible && Boolean.TRUE.equals(PROP_PREVIEW_ON_HOVER.get())) {
920                MainApplication.getMap().mapView.addPrimitiveHoverListener(this);
921            } else {
922                MainApplication.getMap().mapView.removePrimitiveHoverListener(this);
923            }
924        }
925    }
926
927    @Override
928    public void processDatasetEvent(AbstractDatasetChangedEvent event) {
929        updateSelection();
930    }
931
932    /**
933     * Replies the tag popup menu handler.
934     * @return The tag popup menu handler
935     */
936    public PopupMenuHandler getPropertyPopupMenuHandler() {
937        return tagMenuHandler;
938    }
939
940    /**
941     * Returns the selected tag. Value is empty if several tags are selected for a given key.
942     * @return The current selected tag
943     */
944    public Tag getSelectedProperty() {
945        Tags tags = getSelectedProperties();
946        return tags == null ? null : new Tag(
947                tags.getKey(),
948                tags.getValues().size() > 1 ? "" : tags.getValues().iterator().next());
949    }
950
951    /**
952     * Returns the selected tags. Contains all values if several are selected for a given key.
953     * @return The current selected tags
954     * @since 15376
955     */
956    public Tags getSelectedProperties() {
957        int row = tagTable.getSelectedRow();
958        if (row == -1) return null;
959        Map<String, Integer> map = editHelper.getDataValues(row);
960        return new Tags(editHelper.getDataKey(row), map.keySet());
961    }
962
963    /**
964     * Visits all combinations of the selected keys/values.
965     * @param visitor the visitor
966     * @since 15707
967     */
968    public void visitSelectedProperties(KeyValueVisitor visitor) {
969        for (int row : tagTable.getSelectedRows()) {
970            final String key = editHelper.getDataKey(row);
971            Set<String> values = editHelper.getDataValues(row).keySet();
972            values.forEach(value -> visitor.visitKeyValue(null, key, value));
973        }
974    }
975
976    /**
977     * Replies the membership popup menu handler.
978     * @return The membership popup menu handler
979     */
980    public PopupMenuHandler getMembershipPopupMenuHandler() {
981        return membershipMenuHandler;
982    }
983
984    /**
985     * Returns the selected relation membership.
986     * @return The current selected relation membership
987     */
988    public IRelation<?> getSelectedMembershipRelation() {
989        int row = membershipTable.getSelectedRow();
990        return row > -1 ? (IRelation<?>) membershipData.getValueAt(row, 0) : null;
991    }
992
993    /**
994     * Returns all selected relation memberships.
995     * @return The selected relation memberships
996     * @since 15707
997     */
998    public Collection<IRelation<?>> getSelectedMembershipRelations() {
999        return Arrays.stream(membershipTable.getSelectedRows())
1000                .mapToObj(row -> (IRelation<?>) membershipData.getValueAt(row, 0))
1001                .collect(Collectors.toList());
1002    }
1003
1004    /**
1005     * Adds a custom table cell renderer to render cells of the tags table.
1006     *
1007     * If the renderer is not capable performing a {@link TableCellRenderer#getTableCellRendererComponent},
1008     * it should return {@code null} to fall back to the
1009     * {@link PropertiesCellRenderer#getTableCellRendererComponent default implementation}.
1010     * @param renderer the renderer to add
1011     * @since 9149
1012     */
1013    public void addCustomPropertiesCellRenderer(TableCellRenderer renderer) {
1014        cellRenderer.addCustomRenderer(renderer);
1015    }
1016
1017    /**
1018     * Removes a custom table cell renderer.
1019     * @param renderer the renderer to remove
1020     * @since 9149
1021     */
1022    public void removeCustomPropertiesCellRenderer(TableCellRenderer renderer) {
1023        cellRenderer.removeCustomRenderer(renderer);
1024    }
1025
1026    static final class MemberOfCellRenderer extends DefaultTableCellRenderer {
1027        @Override
1028        public Component getTableCellRendererComponent(JTable table, Object value,
1029                boolean isSelected, boolean hasFocus, int row, int column) {
1030            Component c = super.getTableCellRendererComponent(table, value, isSelected, false, row, column);
1031            if (value == null)
1032                return this;
1033            if (c instanceof JLabel) {
1034                JLabel label = (JLabel) c;
1035                IRelation<?> r = (IRelation<?>) value;
1036                label.setText(r.getDisplayName(DefaultNameFormatter.getInstance()));
1037                if (r.isDisabledAndHidden()) {
1038                    label.setFont(label.getFont().deriveFont(Font.ITALIC));
1039                }
1040            }
1041            return c;
1042        }
1043    }
1044
1045    static final class RoleCellRenderer extends DefaultTableCellRenderer {
1046        @Override
1047        public Component getTableCellRendererComponent(JTable table, Object value,
1048                boolean isSelected, boolean hasFocus, int row, int column) {
1049            if (value == null)
1050                return this;
1051            Component c = super.getTableCellRendererComponent(table, value, isSelected, false, row, column);
1052            boolean isDisabledAndHidden = ((IRelation<?>) table.getValueAt(row, 0)).isDisabledAndHidden();
1053            if (c instanceof JLabel) {
1054                JLabel label = (JLabel) c;
1055                label.setText(((MemberInfo) value).getRoleString());
1056                if (isDisabledAndHidden) {
1057                    label.setFont(label.getFont().deriveFont(Font.ITALIC));
1058                }
1059            }
1060            return c;
1061        }
1062    }
1063
1064    static final class PositionCellRenderer extends DefaultTableCellRenderer {
1065        @Override
1066        public Component getTableCellRendererComponent(JTable table, Object value,
1067                boolean isSelected, boolean hasFocus, int row, int column) {
1068            Component c = super.getTableCellRendererComponent(table, value, isSelected, false, row, column);
1069            IRelation<?> relation = (IRelation<?>) table.getValueAt(row, 0);
1070            boolean isDisabledAndHidden = relation != null && relation.isDisabledAndHidden();
1071            if (c instanceof JLabel) {
1072                JLabel label = (JLabel) c;
1073                MemberInfo member = (MemberInfo) table.getValueAt(row, 1);
1074                if (member != null) {
1075                    label.setText(member.getPositionString());
1076                }
1077                if (isDisabledAndHidden) {
1078                    label.setFont(label.getFont().deriveFont(Font.ITALIC));
1079                }
1080            }
1081            return c;
1082        }
1083    }
1084
1085    static final class BlankSpaceMenuLauncher extends PopupMenuLauncher {
1086        BlankSpaceMenuLauncher(JPopupMenu menu) {
1087            super(menu);
1088        }
1089
1090        @Override
1091        protected boolean checkSelection(Component component, Point p) {
1092            if (component instanceof JTable) {
1093                return ((JTable) component).rowAtPoint(p) == -1;
1094            }
1095            return true;
1096        }
1097    }
1098
1099    static final class TaggingPresetCommandHandler implements TaggingPresetHandler {
1100        @Override
1101        public void updateTags(List<Tag> tags) {
1102            Command command = TaggingPreset.createCommand(getSelection(), tags);
1103            if (command != null) {
1104                UndoRedoHandler.getInstance().add(command);
1105            }
1106        }
1107
1108        @Override
1109        public Collection<OsmPrimitive> getSelection() {
1110            return OsmDataManager.getInstance().getInProgressSelection();
1111        }
1112    }
1113
1114    /**
1115     * Class that watches for mouse clicks
1116     * @author imi
1117     */
1118    public class MouseClickWatch extends MouseAdapter {
1119        @Override
1120        public void mouseClicked(MouseEvent e) {
1121            if (e.getClickCount() < 2) {
1122                // single click, clear selection in other table not clicked in
1123                if (e.getSource() == tagTable) {
1124                    membershipTable.clearSelection();
1125                } else if (e.getSource() == membershipTable) {
1126                    tagTable.clearSelection();
1127                }
1128            } else if (e.getSource() == tagTable) {
1129                // double click, edit or add tag
1130                int row = tagTable.rowAtPoint(e.getPoint());
1131                if (row > -1) {
1132                    boolean focusOnKey = tagTable.columnAtPoint(e.getPoint()) == 0;
1133                    editHelper.editTag(row, focusOnKey);
1134                } else {
1135                    editHelper.addTag();
1136                    btnAdd.requestFocusInWindow();
1137                }
1138            } else if (e.getSource() == membershipTable) {
1139                int row = membershipTable.rowAtPoint(e.getPoint());
1140                int col = membershipTable.columnAtPoint(e.getPoint());
1141                if (row > -1 && col == 1) {
1142                    final Relation relation = (Relation) membershipData.getValueAt(row, 0);
1143                    final MemberInfo memberInfo = (MemberInfo) membershipData.getValueAt(row, 1);
1144                    RelationRoleEditor.editRole(relation, memberInfo);
1145                } else if (row > -1) {
1146                    editMembership(row);
1147                }
1148            } else {
1149                editHelper.addTag();
1150                btnAdd.requestFocusInWindow();
1151            }
1152        }
1153
1154        @Override
1155        public void mousePressed(MouseEvent e) {
1156            if (e.getSource() == tagTable) {
1157                membershipTable.clearSelection();
1158            } else if (e.getSource() == membershipTable) {
1159                tagTable.clearSelection();
1160            }
1161        }
1162    }
1163
1164    static class MemberInfo {
1165        private final List<IRelationMember<?>> role = new ArrayList<>();
1166        private Set<IPrimitive> members = new HashSet<>();
1167        private List<Integer> position = new ArrayList<>();
1168        private Collection<? extends IPrimitive> selection;
1169        private String positionString;
1170        private String roleString;
1171
1172        MemberInfo(Collection<? extends IPrimitive> selection) {
1173            this.selection = selection;
1174        }
1175
1176        void add(IRelationMember<?> r, Integer p) {
1177            role.add(r);
1178            members.add(r.getMember());
1179            position.add(p);
1180        }
1181
1182        String getPositionString() {
1183            if (positionString == null) {
1184                positionString = Utils.getPositionListString(position);
1185                // if not all objects from the selection are member of this relation
1186                if (selection.stream().anyMatch(p -> !members.contains(p))) {
1187                    positionString += ",\u2717";
1188                }
1189                members = null;
1190                position = null;
1191                selection = null;
1192            }
1193            return Utils.shortenString(positionString, 20);
1194        }
1195
1196        List<IRelationMember<?>> getRole() {
1197            return Collections.unmodifiableList(role);
1198        }
1199
1200        String getRoleString() {
1201            if (roleString == null) {
1202                for (IRelationMember<?> r : role) {
1203                    if (roleString == null) {
1204                        roleString = r.getRole();
1205                    } else if (!roleString.equals(r.getRole())) {
1206                        roleString = KeyedItem.DIFFERENT_I18N;
1207                        break;
1208                    }
1209                }
1210            }
1211            return roleString;
1212        }
1213
1214        @Override
1215        public String toString() {
1216            return String.format("MemberInfo{roles='%s', positions='%s'}", roleString, positionString);
1217        }
1218    }
1219
1220    /**
1221     * Class that allows fast creation of read-only table model with String columns
1222     */
1223    public static class ReadOnlyTableModel extends DefaultTableModel {
1224        @Override
1225        public boolean isCellEditable(int row, int column) {
1226            return false;
1227        }
1228
1229        @Override
1230        public Class<?> getColumnClass(int columnIndex) {
1231            return String.class;
1232        }
1233    }
1234
1235    /**
1236     * Action handling delete button press in properties dialog.
1237     */
1238    class DeleteAction extends JosmAction implements ListSelectionListener {
1239
1240        private static final String DELETE_FROM_RELATION_PREF = "delete_from_relation";
1241
1242        DeleteAction() {
1243            super(tr("Delete"), /* ICON() */ "dialogs/delete", tr("Delete the selected key in all objects"),
1244                    Shortcut.registerShortcut("properties:delete", tr("Delete Tags"), KeyEvent.VK_D,
1245                            Shortcut.ALT_CTRL_SHIFT), false);
1246            updateEnabledState();
1247        }
1248
1249        protected void deleteTags(int... rows) {
1250            // convert list of rows to HashMap (and find gap for nextKey)
1251            Map<String, String> tags = new HashMap<>(Utils.hashMapInitialCapacity(rows.length));
1252            int nextKeyIndex = rows[0];
1253            for (int row : rows) {
1254                String key = editHelper.getDataKey(row);
1255                if (row == nextKeyIndex + 1) {
1256                    nextKeyIndex = row; // no gap yet
1257                }
1258                tags.put(key, null);
1259            }
1260
1261            // find key to select after deleting other tags
1262            String nextKey = null;
1263            int rowCount = tagData.getRowCount();
1264            if (rowCount > rows.length) {
1265                if (nextKeyIndex == rows[rows.length-1]) {
1266                    // no gap found, pick next or previous key in list
1267                    nextKeyIndex = nextKeyIndex + 1 < rowCount ? nextKeyIndex + 1 : rows[0] - 1;
1268                } else {
1269                    // gap found
1270                    nextKeyIndex++;
1271                }
1272                // We use unfiltered indexes here. So don't use getDataKey()
1273                nextKey = (String) tagData.getValueAt(nextKeyIndex, 0);
1274            }
1275
1276            Collection<OsmPrimitive> sel = OsmDataManager.getInstance().getInProgressSelection();
1277            UndoRedoHandler.getInstance().add(new ChangePropertyCommand(sel, tags));
1278
1279            membershipTable.clearSelection();
1280            if (nextKey != null) {
1281                tagTable.changeSelection(findViewRow(tagTable, tagData, nextKey), 0, false, false);
1282            }
1283        }
1284
1285        protected void deleteFromRelation(int row) {
1286            Relation cur = (Relation) membershipData.getValueAt(row, 0);
1287
1288            Relation nextRelation = null;
1289            int rowCount = membershipTable.getRowCount();
1290            if (rowCount > 1) {
1291                nextRelation = (Relation) membershipData.getValueAt(row + 1 < rowCount ? row + 1 : row - 1, 0);
1292            }
1293
1294            ExtendedDialog ed = new ExtendedDialog(MainApplication.getMainFrame(),
1295                    tr("Change relation"),
1296                    tr("Delete from relation"), tr("Cancel"));
1297            ed.setButtonIcons("dialogs/delete", "cancel");
1298            ed.setContent(tr("Really delete selection from relation {0}?", cur.getDisplayName(DefaultNameFormatter.getInstance())));
1299            ed.toggleEnable(DELETE_FROM_RELATION_PREF);
1300
1301            if (ed.showDialog().getValue() != 1)
1302                return;
1303
1304            List<RelationMember> members = cur.getMembers();
1305            for (OsmPrimitive primitive: OsmDataManager.getInstance().getInProgressSelection()) {
1306                members.removeIf(rm -> rm.getMember() == primitive);
1307            }
1308            UndoRedoHandler.getInstance().add(new ChangeMembersCommand(cur, members));
1309
1310            tagTable.clearSelection();
1311            if (nextRelation != null) {
1312                membershipTable.changeSelection(findViewRow(membershipTable, membershipData, nextRelation), 0, false, false);
1313            }
1314        }
1315
1316        @Override
1317        public void actionPerformed(ActionEvent e) {
1318            if (tagTable.getSelectedRowCount() > 0) {
1319                int[] rows = tagTable.getSelectedRows();
1320                deleteTags(rows);
1321            } else if (membershipTable.getSelectedRowCount() > 0) {
1322                ConditionalOptionPaneUtil.startBulkOperation(DELETE_FROM_RELATION_PREF);
1323                int[] rows = membershipTable.getSelectedRows();
1324                // delete from last relation to conserve row numbers in the table
1325                for (int i = rows.length-1; i >= 0; i--) {
1326                    deleteFromRelation(rows[i]);
1327                }
1328                ConditionalOptionPaneUtil.endBulkOperation(DELETE_FROM_RELATION_PREF);
1329            }
1330        }
1331
1332        @Override
1333        protected final void updateEnabledState() {
1334            DataSet ds = OsmDataManager.getInstance().getActiveDataSet();
1335            setEnabled(ds != null && !ds.isLocked() &&
1336                    ((tagTable != null && tagTable.getSelectedRowCount() >= 1)
1337                    || (membershipTable != null && membershipTable.getSelectedRowCount() > 0)
1338                    ));
1339        }
1340
1341        @Override
1342        public void valueChanged(ListSelectionEvent e) {
1343            updateEnabledState();
1344        }
1345    }
1346
1347    /**
1348     * Action handling add button press in properties dialog.
1349     */
1350    class AddAction extends JosmAction {
1351        AtomicBoolean isPerforming = new AtomicBoolean(false);
1352        AddAction() {
1353            super(tr("Add"), /* ICON() */ "dialogs/add", tr("Add a new key/value pair to all objects"),
1354                    Shortcut.registerShortcut("properties:add", tr("Add Tag"), KeyEvent.VK_A,
1355                            Shortcut.ALT), false);
1356        }
1357
1358        @Override
1359        public void actionPerformed(ActionEvent e) {
1360            if (!/*successful*/isPerforming.compareAndSet(false, true)) {
1361                return;
1362            }
1363            try {
1364                editHelper.addTag();
1365                btnAdd.requestFocusInWindow();
1366            } finally {
1367                isPerforming.set(false);
1368            }
1369        }
1370
1371        @Override
1372        protected final void updateEnabledState() {
1373            DataSet ds = OsmDataManager.getInstance().getActiveDataSet();
1374            setEnabled(ds != null && !ds.isLocked() &&
1375                    !Utils.isEmpty(OsmDataManager.getInstance().getInProgressSelection()));
1376        }
1377    }
1378
1379    /**
1380     * Action handling edit button press in properties dialog.
1381     */
1382    class EditAction extends JosmAction implements ListSelectionListener {
1383        AtomicBoolean isPerforming = new AtomicBoolean(false);
1384        EditAction() {
1385            super(tr("Edit"), /* ICON() */ "dialogs/edit", tr("Edit the value of the selected key for all objects"),
1386                    Shortcut.registerShortcut("properties:edit", tr("Edit: {0}", tr("Edit Tags")), KeyEvent.VK_S,
1387                            Shortcut.ALT), false);
1388            updateEnabledState();
1389        }
1390
1391        @Override
1392        public void actionPerformed(ActionEvent e) {
1393            if (!/*successful*/isPerforming.compareAndSet(false, true)) {
1394                return;
1395            }
1396            try {
1397                if (tagTable.getSelectedRowCount() == 1) {
1398                    int row = tagTable.getSelectedRow();
1399                    editHelper.editTag(row, false);
1400                } else if (membershipTable.getSelectedRowCount() == 1) {
1401                    int row = membershipTable.getSelectedRow();
1402                    editMembership(row);
1403                }
1404            } finally {
1405                isPerforming.set(false);
1406            }
1407        }
1408
1409        @Override
1410        protected void updateEnabledState() {
1411            DataSet ds = OsmDataManager.getInstance().getActiveDataSet();
1412            setEnabled(ds != null && !ds.isLocked() &&
1413                    ((tagTable != null && tagTable.getSelectedRowCount() == 1)
1414                    ^ (membershipTable != null && membershipTable.getSelectedRowCount() == 1)
1415                    ));
1416        }
1417
1418        @Override
1419        public void valueChanged(ListSelectionEvent e) {
1420            updateEnabledState();
1421        }
1422    }
1423
1424    class PasteValueAction extends AbstractAction {
1425        PasteValueAction() {
1426            putValue(NAME, tr("Paste Value"));
1427            putValue(SHORT_DESCRIPTION, tr("Paste the value of the selected tag from clipboard"));
1428            new ImageProvider("paste").getResource().attachImageIcon(this, true);
1429        }
1430
1431        @Override
1432        public void actionPerformed(ActionEvent ae) {
1433            if (tagTable.getSelectedRowCount() != 1)
1434                return;
1435            String key = editHelper.getDataKey(tagTable.getSelectedRow());
1436            Collection<OsmPrimitive> sel = OsmDataManager.getInstance().getInProgressSelection();
1437            String clipboard = ClipboardUtils.getClipboardStringContent();
1438            if (sel.isEmpty() || clipboard == null || sel.iterator().next().getDataSet().isLocked())
1439                return;
1440            UndoRedoHandler.getInstance().add(new ChangePropertyCommand(sel, key, Utils.strip(clipboard)));
1441        }
1442    }
1443
1444    class SearchAction extends AbstractAction {
1445        private final boolean sameType;
1446
1447        SearchAction(boolean sameType) {
1448            this.sameType = sameType;
1449            if (sameType) {
1450                putValue(NAME, tr("Search Key/Value/Type"));
1451                putValue(SHORT_DESCRIPTION, tr("Search with the key and value of the selected tag, restrict to type (i.e., node/way/relation)"));
1452                new ImageProvider("dialogs/search").getResource().attachImageIcon(this, true);
1453            } else {
1454                putValue(NAME, tr("Search Key/Value"));
1455                putValue(SHORT_DESCRIPTION, tr("Search with the key and value of the selected tag"));
1456                new ImageProvider("dialogs/search").getResource().attachImageIcon(this, true);
1457            }
1458        }
1459
1460        @Override
1461        public void actionPerformed(ActionEvent e) {
1462            if (tagTable.getSelectedRowCount() != 1)
1463                return;
1464            String key = editHelper.getDataKey(tagTable.getSelectedRow());
1465            Collection<? extends IPrimitive> sel = OsmDataManager.getInstance().getInProgressISelection();
1466            if (sel.isEmpty())
1467                return;
1468            final SearchSetting ss = createSearchSetting(key, sel, sameType);
1469            searchStateless(ss);
1470        }
1471    }
1472
1473    static SearchSetting createSearchSetting(String key, Collection<? extends IPrimitive> sel, boolean sameType) {
1474        String sep = "";
1475        StringBuilder s = new StringBuilder();
1476        Set<String> consideredTokens = new TreeSet<>();
1477        for (IPrimitive p : sel) {
1478            String val = p.get(key);
1479            if (val == null || (!sameType && consideredTokens.contains(val))) {
1480                continue;
1481            }
1482            String t = "";
1483            if (!sameType) {
1484                t = "";
1485            } else if (p instanceof Node) {
1486                t = "type:node ";
1487            } else if (p instanceof Way) {
1488                t = "type:way ";
1489            } else if (p instanceof Relation) {
1490                t = "type:relation ";
1491            }
1492            String token = t + val;
1493            if (consideredTokens.add(token)) {
1494                s.append(sep).append('(').append(t).append(SearchCompiler.buildSearchStringForTag(key, val)).append(')');
1495                sep = " OR ";
1496            }
1497        }
1498
1499        final SearchSetting ss = new SearchSetting();
1500        ss.text = s.toString();
1501        ss.caseSensitive = true;
1502        return ss;
1503    }
1504
1505    /**
1506     * Clears the row selection when it is filtered away by the row sorter.
1507     */
1508    private final class RemoveHiddenSelection implements ListSelectionListener, RowSorterListener {
1509
1510        void removeHiddenSelection() {
1511            try {
1512                tagRowSorter.convertRowIndexToModel(tagTable.getSelectedRow());
1513            } catch (IndexOutOfBoundsException e) {
1514                Logging.trace(e);
1515                Logging.trace("Clearing tagTable selection");
1516                tagTable.clearSelection();
1517            }
1518        }
1519
1520        @Override
1521        public void valueChanged(ListSelectionEvent event) {
1522            removeHiddenSelection();
1523        }
1524
1525        @Override
1526        public void sorterChanged(RowSorterEvent e) {
1527            removeHiddenSelection();
1528        }
1529    }
1530
1531    private final class HoverPreviewPropListener implements ValueChangeListener<Boolean> {
1532        @Override
1533        public void valueChanged(ValueChangeEvent<? extends Boolean> e) {
1534            if (Boolean.TRUE.equals(e.getProperty().get()) && isDialogShowing()) {
1535                MainApplication.getMap().mapView.addPrimitiveHoverListener(PropertiesDialog.this);
1536            } else if (Boolean.FALSE.equals(e.getProperty().get())) {
1537                MainApplication.getMap().mapView.removePrimitiveHoverListener(PropertiesDialog.this);
1538            }
1539        }
1540    }
1541
1542    /*
1543     * Ensure HoverListener is re-added when selection priority is disabled while something is selected.
1544     * Otherwise user would need to change selection to see the preference change take effect.
1545     */
1546    private final class HoverPreviewPreferSelectionPropListener implements ValueChangeListener<Boolean> {
1547        @Override
1548        public void valueChanged(ValueChangeEvent<? extends Boolean> e) {
1549            if (Boolean.FALSE.equals(e.getProperty().get()) &&
1550                Boolean.TRUE.equals(PROP_PREVIEW_ON_HOVER.get()) &&
1551                isDialogShowing()) {
1552                MainApplication.getMap().mapView.addPrimitiveHoverListener(PropertiesDialog.this);
1553            }
1554        }
1555    }
1556}