source: josm/trunk/src/org/openstreetmap/josm/gui/dialogs/properties/PropertiesDialog.java@ 19050

Last change on this file since 19050 was 19050, checked in by taylor.smock, 6 weeks ago

Revert most var changes from r19048, fix most new compile warnings and checkstyle issues

Also, document why various ErrorProne checks were originally disabled and fix
generic SonarLint issues.
  • Property svn:eol-style set to native
File size: 65.1 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.gui.dialogs.properties;
3
4import static org.openstreetmap.josm.actions.search.SearchAction.searchStateless;
5import static org.openstreetmap.josm.tools.I18n.tr;
6
7import java.awt.Component;
8import java.awt.Container;
9import java.awt.Font;
10import java.awt.GridBagConstraints;
11import java.awt.GridBagLayout;
12import java.awt.Point;
13import java.awt.event.ActionEvent;
14import java.awt.event.KeyEvent;
15import java.awt.event.MouseAdapter;
16import java.awt.event.MouseEvent;
17import java.beans.PropertyChangeEvent;
18import java.beans.PropertyChangeListener;
19import java.util.ArrayList;
20import java.util.Arrays;
21import java.util.Collection;
22import java.util.Collections;
23import java.util.EnumSet;
24import java.util.HashMap;
25import java.util.HashSet;
26import java.util.List;
27import java.util.Map;
28import java.util.Map.Entry;
29import java.util.Set;
30import java.util.TreeMap;
31import java.util.TreeSet;
32import java.util.concurrent.atomic.AtomicBoolean;
33import java.util.stream.Collectors;
34
35import javax.swing.AbstractAction;
36import javax.swing.JComponent;
37import javax.swing.JLabel;
38import javax.swing.JMenuItem;
39import javax.swing.JPanel;
40import javax.swing.JPopupMenu;
41import javax.swing.JScrollPane;
42import javax.swing.JTable;
43import javax.swing.KeyStroke;
44import javax.swing.ListSelectionModel;
45import javax.swing.event.ListSelectionEvent;
46import javax.swing.event.ListSelectionListener;
47import javax.swing.event.PopupMenuEvent;
48import javax.swing.event.RowSorterEvent;
49import javax.swing.event.RowSorterListener;
50import javax.swing.table.DefaultTableCellRenderer;
51import javax.swing.table.DefaultTableModel;
52import javax.swing.table.TableCellRenderer;
53import javax.swing.table.TableColumnModel;
54import javax.swing.table.TableModel;
55import javax.swing.table.TableRowSorter;
56
57import org.openstreetmap.josm.actions.JosmAction;
58import org.openstreetmap.josm.actions.relation.DeleteRelationsAction;
59import org.openstreetmap.josm.actions.relation.DuplicateRelationAction;
60import org.openstreetmap.josm.actions.relation.EditRelationAction;
61import org.openstreetmap.josm.command.ChangeMembersCommand;
62import org.openstreetmap.josm.command.ChangePropertyCommand;
63import org.openstreetmap.josm.command.Command;
64import org.openstreetmap.josm.data.UndoRedoHandler;
65import org.openstreetmap.josm.data.coor.LatLon;
66import org.openstreetmap.josm.data.osm.AbstractPrimitive;
67import org.openstreetmap.josm.data.osm.DataSelectionListener;
68import org.openstreetmap.josm.data.osm.DataSet;
69import org.openstreetmap.josm.data.osm.DefaultNameFormatter;
70import org.openstreetmap.josm.data.osm.IPrimitive;
71import org.openstreetmap.josm.data.osm.IRelation;
72import org.openstreetmap.josm.data.osm.IRelationMember;
73import org.openstreetmap.josm.data.osm.KeyValueVisitor;
74import org.openstreetmap.josm.data.osm.Node;
75import org.openstreetmap.josm.data.osm.OsmDataManager;
76import org.openstreetmap.josm.data.osm.OsmPrimitive;
77import org.openstreetmap.josm.data.osm.Relation;
78import org.openstreetmap.josm.data.osm.RelationMember;
79import org.openstreetmap.josm.data.osm.Tag;
80import org.openstreetmap.josm.data.osm.Tags;
81import org.openstreetmap.josm.data.osm.Way;
82import org.openstreetmap.josm.data.osm.event.AbstractDatasetChangedEvent;
83import org.openstreetmap.josm.data.osm.event.DataSetListenerAdapter;
84import org.openstreetmap.josm.data.osm.event.DatasetEventManager;
85import org.openstreetmap.josm.data.osm.event.DatasetEventManager.FireMode;
86import org.openstreetmap.josm.data.osm.event.SelectionEventManager;
87import org.openstreetmap.josm.data.osm.search.SearchCompiler;
88import org.openstreetmap.josm.data.osm.search.SearchSetting;
89import org.openstreetmap.josm.data.preferences.AbstractProperty.ValueChangeEvent;
90import org.openstreetmap.josm.data.preferences.AbstractProperty.ValueChangeListener;
91import org.openstreetmap.josm.data.preferences.BooleanProperty;
92import org.openstreetmap.josm.data.preferences.CachingProperty;
93import org.openstreetmap.josm.gui.ConditionalOptionPaneUtil;
94import org.openstreetmap.josm.gui.ExtendedDialog;
95import org.openstreetmap.josm.gui.MainApplication;
96import org.openstreetmap.josm.gui.PopupMenuHandler;
97import org.openstreetmap.josm.gui.PrimitiveHoverListener;
98import org.openstreetmap.josm.gui.SideButton;
99import 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 tagTableFilter.setVisible(hasTags);
827 selectSth.setVisible(!hasSelection);
828 pluginHook.setVisible(hasSelection);
829 }
830
831 private void updateActionsEnabledState() {
832 addAction.updateEnabledState();
833 editAction.updateEnabledState();
834 deleteAction.updateEnabledState();
835 }
836
837 private void updateTitle(Collection<? extends IPrimitive> primitives) {
838 int newSelSize = primitives.size();
839 if (tagData.getRowCount() != 0 || membershipData.getRowCount() != 0) {
840 if (newSelSize > 1) {
841 setTitle(tr("Objects: {2} / Tags: {0} / Memberships: {1}",
842 tagData.getRowCount(), membershipData.getRowCount(), newSelSize));
843 } else {
844 setTitle(tr("Tags: {0} / Memberships: {1}",
845 tagData.getRowCount(), membershipData.getRowCount()));
846 }
847 } else {
848 setTitle(tr("Tags/Memberships"));
849 }
850 }
851
852 /* ---------------------------------------------------------------------------------- */
853 /* PreferenceChangedListener */
854 /* ---------------------------------------------------------------------------------- */
855
856 /**
857 * Reloads data when the {@code display.discardable-keys} preference changes
858 */
859 @Override
860 public void preferenceChanged(PreferenceChangeEvent e) {
861 super.preferenceChanged(e);
862 if (PROP_DISPLAY_DISCARDABLE_KEYS.getKey().equals(e.getKey()) && MainApplication.getLayerManager().getActiveData() != null) {
863 updateSelection();
864 }
865 }
866
867 /* ---------------------------------------------------------------------------------- */
868 /* TaggingPresetListener */
869 /* ---------------------------------------------------------------------------------- */
870
871 /**
872 * Updates the preset list when Presets preference changes.
873 */
874 @Override
875 public void taggingPresetsModified() {
876 if (MainApplication.getLayerManager().getActiveData() != null) {
877 updateSelection();
878 }
879 }
880
881 /* ---------------------------------------------------------------------------------- */
882 /* ActiveLayerChangeListener */
883 /* ---------------------------------------------------------------------------------- */
884 @Override
885 public void activeOrEditLayerChanged(ActiveLayerChangeEvent e) {
886 if (e.getSource().getEditLayer() == null) {
887 editHelper.saveTagsIfNeeded();
888 editHelper.resetSelection();
889 }
890 // it is time to save history of tags
891 updateSelection();
892
893 // Listen for active layer visibility change to enable/disable hover preview
894 // Remove previous listener first (order matters if we are somehow getting a layer change event
895 // switching from one layer to the same layer)
896 Layer prevLayer = e.getPreviousDataLayer();
897 if (prevLayer != null) {
898 prevLayer.removePropertyChangeListener(this);
899 }
900
901 Layer newLayer = e.getSource().getActiveDataLayer();
902 if (newLayer != null) {
903 newLayer.addPropertyChangeListener(this);
904 if (newLayer.isVisible() && Boolean.TRUE.equals(PROP_PREVIEW_ON_HOVER.get())) {
905 MainApplication.getMap().mapView.addPrimitiveHoverListener(this);
906 } else {
907 MainApplication.getMap().mapView.removePrimitiveHoverListener(this);
908 }
909 }
910 }
911
912 @Override
913 public void propertyChange(PropertyChangeEvent e) {
914 if (Layer.VISIBLE_PROP.equals(e.getPropertyName())) {
915 boolean isVisible = (boolean) e.getNewValue();
916
917 // Disable hover preview when primitives are invisible
918 if (isVisible && Boolean.TRUE.equals(PROP_PREVIEW_ON_HOVER.get())) {
919 MainApplication.getMap().mapView.addPrimitiveHoverListener(this);
920 } else {
921 MainApplication.getMap().mapView.removePrimitiveHoverListener(this);
922 }
923 }
924 }
925
926 @Override
927 public void processDatasetEvent(AbstractDatasetChangedEvent event) {
928 updateSelection();
929 }
930
931 /**
932 * Replies the tag popup menu handler.
933 * @return The tag popup menu handler
934 */
935 public PopupMenuHandler getPropertyPopupMenuHandler() {
936 return tagMenuHandler;
937 }
938
939 /**
940 * Returns the selected tag. Value is empty if several tags are selected for a given key.
941 * @return The current selected tag
942 */
943 public Tag getSelectedProperty() {
944 Tags tags = getSelectedProperties();
945 return tags == null ? null : new Tag(
946 tags.getKey(),
947 tags.getValues().size() > 1 ? "" : tags.getValues().iterator().next());
948 }
949
950 /**
951 * Returns the selected tags. Contains all values if several are selected for a given key.
952 * @return The current selected tags
953 * @since 15376
954 */
955 public Tags getSelectedProperties() {
956 int row = tagTable.getSelectedRow();
957 if (row == -1) return null;
958 Map<String, Integer> map = editHelper.getDataValues(row);
959 return new Tags(editHelper.getDataKey(row), map.keySet());
960 }
961
962 /**
963 * Visits all combinations of the selected keys/values.
964 * @param visitor the visitor
965 * @since 15707
966 */
967 public void visitSelectedProperties(KeyValueVisitor visitor) {
968 for (int row : tagTable.getSelectedRows()) {
969 final String key = editHelper.getDataKey(row);
970 Set<String> values = editHelper.getDataValues(row).keySet();
971 values.forEach(value -> visitor.visitKeyValue(null, key, value));
972 }
973 }
974
975 /**
976 * Replies the membership popup menu handler.
977 * @return The membership popup menu handler
978 */
979 public PopupMenuHandler getMembershipPopupMenuHandler() {
980 return membershipMenuHandler;
981 }
982
983 /**
984 * Returns the selected relation membership.
985 * @return The current selected relation membership
986 */
987 public IRelation<?> getSelectedMembershipRelation() {
988 int row = membershipTable.getSelectedRow();
989 return row > -1 ? (IRelation<?>) membershipData.getValueAt(row, 0) : null;
990 }
991
992 /**
993 * Returns all selected relation memberships.
994 * @return The selected relation memberships
995 * @since 15707
996 */
997 public Collection<IRelation<?>> getSelectedMembershipRelations() {
998 return Arrays.stream(membershipTable.getSelectedRows())
999 .mapToObj(row -> (IRelation<?>) membershipData.getValueAt(row, 0))
1000 .collect(Collectors.toList());
1001 }
1002
1003 /**
1004 * Adds a custom table cell renderer to render cells of the tags table.
1005 *
1006 * If the renderer is not capable performing a {@link TableCellRenderer#getTableCellRendererComponent},
1007 * it should return {@code null} to fall back to the
1008 * {@link PropertiesCellRenderer#getTableCellRendererComponent default implementation}.
1009 * @param renderer the renderer to add
1010 * @since 9149
1011 */
1012 public void addCustomPropertiesCellRenderer(TableCellRenderer renderer) {
1013 cellRenderer.addCustomRenderer(renderer);
1014 }
1015
1016 /**
1017 * Removes a custom table cell renderer.
1018 * @param renderer the renderer to remove
1019 * @since 9149
1020 */
1021 public void removeCustomPropertiesCellRenderer(TableCellRenderer renderer) {
1022 cellRenderer.removeCustomRenderer(renderer);
1023 }
1024
1025 static final class MemberOfCellRenderer extends DefaultTableCellRenderer {
1026 @Override
1027 public Component getTableCellRendererComponent(JTable table, Object value,
1028 boolean isSelected, boolean hasFocus, int row, int column) {
1029 Component c = super.getTableCellRendererComponent(table, value, isSelected, false, row, column);
1030 if (value == null)
1031 return this;
1032 if (c instanceof JLabel) {
1033 JLabel label = (JLabel) c;
1034 IRelation<?> r = (IRelation<?>) value;
1035 label.setText(r.getDisplayName(DefaultNameFormatter.getInstance()));
1036 if (r.isDisabledAndHidden()) {
1037 label.setFont(label.getFont().deriveFont(Font.ITALIC));
1038 }
1039 }
1040 return c;
1041 }
1042 }
1043
1044 static final class RoleCellRenderer extends DefaultTableCellRenderer {
1045 @Override
1046 public Component getTableCellRendererComponent(JTable table, Object value,
1047 boolean isSelected, boolean hasFocus, int row, int column) {
1048 if (value == null)
1049 return this;
1050 Component c = super.getTableCellRendererComponent(table, value, isSelected, false, row, column);
1051 boolean isDisabledAndHidden = ((IRelation<?>) table.getValueAt(row, 0)).isDisabledAndHidden();
1052 if (c instanceof JLabel) {
1053 JLabel label = (JLabel) c;
1054 label.setText(((MemberInfo) value).getRoleString());
1055 if (isDisabledAndHidden) {
1056 label.setFont(label.getFont().deriveFont(Font.ITALIC));
1057 }
1058 }
1059 return c;
1060 }
1061 }
1062
1063 static final class PositionCellRenderer extends DefaultTableCellRenderer {
1064 @Override
1065 public Component getTableCellRendererComponent(JTable table, Object value,
1066 boolean isSelected, boolean hasFocus, int row, int column) {
1067 Component c = super.getTableCellRendererComponent(table, value, isSelected, false, row, column);
1068 IRelation<?> relation = (IRelation<?>) table.getValueAt(row, 0);
1069 boolean isDisabledAndHidden = relation != null && relation.isDisabledAndHidden();
1070 if (c instanceof JLabel) {
1071 JLabel label = (JLabel) c;
1072 MemberInfo member = (MemberInfo) table.getValueAt(row, 1);
1073 if (member != null) {
1074 label.setText(member.getPositionString());
1075 }
1076 if (isDisabledAndHidden) {
1077 label.setFont(label.getFont().deriveFont(Font.ITALIC));
1078 }
1079 }
1080 return c;
1081 }
1082 }
1083
1084 static final class BlankSpaceMenuLauncher extends PopupMenuLauncher {
1085 BlankSpaceMenuLauncher(JPopupMenu menu) {
1086 super(menu);
1087 }
1088
1089 @Override
1090 protected boolean checkSelection(Component component, Point p) {
1091 if (component instanceof JTable) {
1092 return ((JTable) component).rowAtPoint(p) == -1;
1093 }
1094 return true;
1095 }
1096 }
1097
1098 static final class TaggingPresetCommandHandler implements TaggingPresetHandler {
1099 @Override
1100 public void updateTags(List<Tag> tags) {
1101 Command command = TaggingPreset.createCommand(getSelection(), tags);
1102 if (command != null) {
1103 UndoRedoHandler.getInstance().add(command);
1104 }
1105 }
1106
1107 @Override
1108 public Collection<OsmPrimitive> getSelection() {
1109 return OsmDataManager.getInstance().getInProgressSelection();
1110 }
1111 }
1112
1113 /**
1114 * Class that watches for mouse clicks
1115 * @author imi
1116 */
1117 public class MouseClickWatch extends MouseAdapter {
1118 @Override
1119 public void mouseClicked(MouseEvent e) {
1120 if (e.getClickCount() < 2) {
1121 // single click, clear selection in other table not clicked in
1122 if (e.getSource() == tagTable) {
1123 membershipTable.clearSelection();
1124 } else if (e.getSource() == membershipTable) {
1125 tagTable.clearSelection();
1126 }
1127 } else if (e.getSource() == tagTable) {
1128 // double click, edit or add tag
1129 int row = tagTable.rowAtPoint(e.getPoint());
1130 if (row > -1) {
1131 boolean focusOnKey = tagTable.columnAtPoint(e.getPoint()) == 0;
1132 editHelper.editTag(row, focusOnKey);
1133 } else {
1134 editHelper.addTag();
1135 btnAdd.requestFocusInWindow();
1136 }
1137 } else if (e.getSource() == membershipTable) {
1138 int row = membershipTable.rowAtPoint(e.getPoint());
1139 int col = membershipTable.columnAtPoint(e.getPoint());
1140 if (row > -1 && col == 1) {
1141 final Relation relation = (Relation) membershipData.getValueAt(row, 0);
1142 final MemberInfo memberInfo = (MemberInfo) membershipData.getValueAt(row, 1);
1143 RelationRoleEditor.editRole(relation, memberInfo);
1144 } else if (row > -1) {
1145 editMembership(row);
1146 }
1147 } else {
1148 editHelper.addTag();
1149 btnAdd.requestFocusInWindow();
1150 }
1151 }
1152
1153 @Override
1154 public void mousePressed(MouseEvent e) {
1155 if (e.getSource() == tagTable) {
1156 membershipTable.clearSelection();
1157 } else if (e.getSource() == membershipTable) {
1158 tagTable.clearSelection();
1159 }
1160 }
1161 }
1162
1163 static class MemberInfo {
1164 private final List<IRelationMember<?>> role = new ArrayList<>();
1165 private Set<IPrimitive> members = new HashSet<>();
1166 private List<Integer> position = new ArrayList<>();
1167 private Collection<? extends IPrimitive> selection;
1168 private String positionString;
1169 private String roleString;
1170
1171 MemberInfo(Collection<? extends IPrimitive> selection) {
1172 this.selection = selection;
1173 }
1174
1175 void add(IRelationMember<?> r, Integer p) {
1176 role.add(r);
1177 members.add(r.getMember());
1178 position.add(p);
1179 }
1180
1181 String getPositionString() {
1182 if (positionString == null) {
1183 positionString = Utils.getPositionListString(position);
1184 // if not all objects from the selection are member of this relation
1185 if (selection.stream().anyMatch(p -> !members.contains(p))) {
1186 positionString += ",\u2717";
1187 }
1188 members = null;
1189 position = null;
1190 selection = null;
1191 }
1192 return Utils.shortenString(positionString, 20);
1193 }
1194
1195 List<IRelationMember<?>> getRole() {
1196 return Collections.unmodifiableList(role);
1197 }
1198
1199 String getRoleString() {
1200 if (roleString == null) {
1201 for (IRelationMember<?> r : role) {
1202 if (roleString == null) {
1203 roleString = r.getRole();
1204 } else if (!roleString.equals(r.getRole())) {
1205 roleString = KeyedItem.DIFFERENT_I18N;
1206 break;
1207 }
1208 }
1209 }
1210 return roleString;
1211 }
1212
1213 @Override
1214 public String toString() {
1215 return String.format("MemberInfo{roles='%s', positions='%s'}", roleString, positionString);
1216 }
1217 }
1218
1219 /**
1220 * Class that allows fast creation of read-only table model with String columns
1221 */
1222 public static class ReadOnlyTableModel extends DefaultTableModel {
1223 @Override
1224 public boolean isCellEditable(int row, int column) {
1225 return false;
1226 }
1227
1228 @Override
1229 public Class<?> getColumnClass(int columnIndex) {
1230 return String.class;
1231 }
1232 }
1233
1234 /**
1235 * Action handling delete button press in properties dialog.
1236 */
1237 class DeleteAction extends JosmAction implements ListSelectionListener {
1238
1239 private static final String DELETE_FROM_RELATION_PREF = "delete_from_relation";
1240
1241 DeleteAction() {
1242 super(tr("Delete"), /* ICON() */ "dialogs/delete", tr("Delete the selected key in all objects"),
1243 Shortcut.registerShortcut("properties:delete", tr("Delete Tags"), KeyEvent.VK_D,
1244 Shortcut.ALT_CTRL_SHIFT), false);
1245 updateEnabledState();
1246 }
1247
1248 protected void deleteTags(int... rows) {
1249 // convert list of rows to HashMap (and find gap for nextKey)
1250 Map<String, String> tags = new HashMap<>(Utils.hashMapInitialCapacity(rows.length));
1251 int nextKeyIndex = rows[0];
1252 for (int row : rows) {
1253 String key = editHelper.getDataKey(row);
1254 if (row == nextKeyIndex + 1) {
1255 nextKeyIndex = row; // no gap yet
1256 }
1257 tags.put(key, null);
1258 }
1259
1260 // find key to select after deleting other tags
1261 String nextKey = null;
1262 int rowCount = tagData.getRowCount();
1263 if (rowCount > rows.length) {
1264 if (nextKeyIndex == rows[rows.length-1]) {
1265 // no gap found, pick next or previous key in list
1266 nextKeyIndex = nextKeyIndex + 1 < rowCount ? nextKeyIndex + 1 : rows[0] - 1;
1267 } else {
1268 // gap found
1269 nextKeyIndex++;
1270 }
1271 // We use unfiltered indexes here. So don't use getDataKey()
1272 nextKey = (String) tagData.getValueAt(nextKeyIndex, 0);
1273 }
1274
1275 Collection<OsmPrimitive> sel = OsmDataManager.getInstance().getInProgressSelection();
1276 UndoRedoHandler.getInstance().add(new ChangePropertyCommand(sel, tags));
1277
1278 membershipTable.clearSelection();
1279 if (nextKey != null) {
1280 tagTable.changeSelection(findViewRow(tagTable, tagData, nextKey), 0, false, false);
1281 }
1282 }
1283
1284 protected void deleteFromRelation(int row) {
1285 Relation cur = (Relation) membershipData.getValueAt(row, 0);
1286
1287 Relation nextRelation = null;
1288 int rowCount = membershipTable.getRowCount();
1289 if (rowCount > 1) {
1290 nextRelation = (Relation) membershipData.getValueAt(row + 1 < rowCount ? row + 1 : row - 1, 0);
1291 }
1292
1293 ExtendedDialog ed = new ExtendedDialog(MainApplication.getMainFrame(),
1294 tr("Change relation"),
1295 tr("Delete from relation"), tr("Cancel"));
1296 ed.setButtonIcons("dialogs/delete", "cancel");
1297 ed.setContent(tr("Really delete selection from relation {0}?", cur.getDisplayName(DefaultNameFormatter.getInstance())));
1298 ed.toggleEnable(DELETE_FROM_RELATION_PREF);
1299
1300 if (ed.showDialog().getValue() != 1)
1301 return;
1302
1303 List<RelationMember> members = cur.getMembers();
1304 for (OsmPrimitive primitive: OsmDataManager.getInstance().getInProgressSelection()) {
1305 members.removeIf(rm -> rm.getMember() == primitive);
1306 }
1307 UndoRedoHandler.getInstance().add(new ChangeMembersCommand(cur, members));
1308
1309 tagTable.clearSelection();
1310 if (nextRelation != null) {
1311 membershipTable.changeSelection(findViewRow(membershipTable, membershipData, nextRelation), 0, false, false);
1312 }
1313 }
1314
1315 @Override
1316 public void actionPerformed(ActionEvent e) {
1317 if (tagTable.getSelectedRowCount() > 0) {
1318 int[] rows = tagTable.getSelectedRows();
1319 deleteTags(rows);
1320 } else if (membershipTable.getSelectedRowCount() > 0) {
1321 ConditionalOptionPaneUtil.startBulkOperation(DELETE_FROM_RELATION_PREF);
1322 int[] rows = membershipTable.getSelectedRows();
1323 // delete from last relation to conserve row numbers in the table
1324 for (int i = rows.length-1; i >= 0; i--) {
1325 deleteFromRelation(rows[i]);
1326 }
1327 ConditionalOptionPaneUtil.endBulkOperation(DELETE_FROM_RELATION_PREF);
1328 }
1329 }
1330
1331 @Override
1332 protected final void updateEnabledState() {
1333 DataSet ds = OsmDataManager.getInstance().getActiveDataSet();
1334 setEnabled(ds != null && !ds.isLocked() &&
1335 ((tagTable != null && tagTable.getSelectedRowCount() >= 1)
1336 || (membershipTable != null && membershipTable.getSelectedRowCount() > 0)
1337 ));
1338 }
1339
1340 @Override
1341 public void valueChanged(ListSelectionEvent e) {
1342 updateEnabledState();
1343 }
1344 }
1345
1346 /**
1347 * Action handling add button press in properties dialog.
1348 */
1349 class AddAction extends JosmAction {
1350 AtomicBoolean isPerforming = new AtomicBoolean(false);
1351 AddAction() {
1352 super(tr("Add"), /* ICON() */ "dialogs/add", tr("Add a new key/value pair to all objects"),
1353 Shortcut.registerShortcut("properties:add", tr("Add Tag"), KeyEvent.VK_A,
1354 Shortcut.ALT), false);
1355 }
1356
1357 @Override
1358 public void actionPerformed(ActionEvent e) {
1359 if (!/*successful*/isPerforming.compareAndSet(false, true)) {
1360 return;
1361 }
1362 try {
1363 editHelper.addTag();
1364 btnAdd.requestFocusInWindow();
1365 } finally {
1366 isPerforming.set(false);
1367 }
1368 }
1369
1370 @Override
1371 protected final void updateEnabledState() {
1372 DataSet ds = OsmDataManager.getInstance().getActiveDataSet();
1373 setEnabled(ds != null && !ds.isLocked() &&
1374 !Utils.isEmpty(OsmDataManager.getInstance().getInProgressSelection()));
1375 }
1376 }
1377
1378 /**
1379 * Action handling edit button press in properties dialog.
1380 */
1381 class EditAction extends JosmAction implements ListSelectionListener {
1382 AtomicBoolean isPerforming = new AtomicBoolean(false);
1383 EditAction() {
1384 super(tr("Edit"), /* ICON() */ "dialogs/edit", tr("Edit the value of the selected key for all objects"),
1385 Shortcut.registerShortcut("properties:edit", tr("Edit: {0}", tr("Edit Tags")), KeyEvent.VK_S,
1386 Shortcut.ALT), false);
1387 updateEnabledState();
1388 }
1389
1390 @Override
1391 public void actionPerformed(ActionEvent e) {
1392 if (!/*successful*/isPerforming.compareAndSet(false, true)) {
1393 return;
1394 }
1395 try {
1396 if (tagTable.getSelectedRowCount() == 1) {
1397 int row = tagTable.getSelectedRow();
1398 editHelper.editTag(row, false);
1399 } else if (membershipTable.getSelectedRowCount() == 1) {
1400 int row = membershipTable.getSelectedRow();
1401 editMembership(row);
1402 }
1403 } finally {
1404 isPerforming.set(false);
1405 }
1406 }
1407
1408 @Override
1409 protected void updateEnabledState() {
1410 DataSet ds = OsmDataManager.getInstance().getActiveDataSet();
1411 setEnabled(ds != null && !ds.isLocked() &&
1412 ((tagTable != null && tagTable.getSelectedRowCount() == 1)
1413 ^ (membershipTable != null && membershipTable.getSelectedRowCount() == 1)
1414 ));
1415 }
1416
1417 @Override
1418 public void valueChanged(ListSelectionEvent e) {
1419 updateEnabledState();
1420 }
1421 }
1422
1423 class PasteValueAction extends AbstractAction {
1424 PasteValueAction() {
1425 putValue(NAME, tr("Paste Value"));
1426 putValue(SHORT_DESCRIPTION, tr("Paste the value of the selected tag from clipboard"));
1427 new ImageProvider("paste").getResource().attachImageIcon(this, true);
1428 }
1429
1430 @Override
1431 public void actionPerformed(ActionEvent ae) {
1432 if (tagTable.getSelectedRowCount() != 1)
1433 return;
1434 String key = editHelper.getDataKey(tagTable.getSelectedRow());
1435 Collection<OsmPrimitive> sel = OsmDataManager.getInstance().getInProgressSelection();
1436 String clipboard = ClipboardUtils.getClipboardStringContent();
1437 if (sel.isEmpty() || clipboard == null || sel.iterator().next().getDataSet().isLocked())
1438 return;
1439 UndoRedoHandler.getInstance().add(new ChangePropertyCommand(sel, key, Utils.strip(clipboard)));
1440 }
1441 }
1442
1443 class SearchAction extends AbstractAction {
1444 private final boolean sameType;
1445
1446 SearchAction(boolean sameType) {
1447 this.sameType = sameType;
1448 if (sameType) {
1449 putValue(NAME, tr("Search Key/Value/Type"));
1450 putValue(SHORT_DESCRIPTION, tr("Search with the key and value of the selected tag, restrict to type (i.e., node/way/relation)"));
1451 new ImageProvider("dialogs/search").getResource().attachImageIcon(this, true);
1452 } else {
1453 putValue(NAME, tr("Search Key/Value"));
1454 putValue(SHORT_DESCRIPTION, tr("Search with the key and value of the selected tag"));
1455 new ImageProvider("dialogs/search").getResource().attachImageIcon(this, true);
1456 }
1457 }
1458
1459 @Override
1460 public void actionPerformed(ActionEvent e) {
1461 if (tagTable.getSelectedRowCount() != 1)
1462 return;
1463 String key = editHelper.getDataKey(tagTable.getSelectedRow());
1464 Collection<? extends IPrimitive> sel = OsmDataManager.getInstance().getInProgressISelection();
1465 if (sel.isEmpty())
1466 return;
1467 final SearchSetting ss = createSearchSetting(key, sel, sameType);
1468 searchStateless(ss);
1469 }
1470 }
1471
1472 static SearchSetting createSearchSetting(String key, Collection<? extends IPrimitive> sel, boolean sameType) {
1473 String sep = "";
1474 StringBuilder s = new StringBuilder();
1475 Set<String> consideredTokens = new TreeSet<>();
1476 for (IPrimitive p : sel) {
1477 String val = p.get(key);
1478 if (val == null || (!sameType && consideredTokens.contains(val))) {
1479 continue;
1480 }
1481 String t = "";
1482 if (!sameType) {
1483 t = "";
1484 } else if (p instanceof Node) {
1485 t = "type:node ";
1486 } else if (p instanceof Way) {
1487 t = "type:way ";
1488 } else if (p instanceof Relation) {
1489 t = "type:relation ";
1490 }
1491 String token = t + val;
1492 if (consideredTokens.add(token)) {
1493 s.append(sep).append('(').append(t).append(SearchCompiler.buildSearchStringForTag(key, val)).append(')');
1494 sep = " OR ";
1495 }
1496 }
1497
1498 final SearchSetting ss = new SearchSetting();
1499 ss.text = s.toString();
1500 ss.caseSensitive = true;
1501 return ss;
1502 }
1503
1504 /**
1505 * Clears the row selection when it is filtered away by the row sorter.
1506 */
1507 private final class RemoveHiddenSelection implements ListSelectionListener, RowSorterListener {
1508
1509 void removeHiddenSelection() {
1510 try {
1511 tagRowSorter.convertRowIndexToModel(tagTable.getSelectedRow());
1512 } catch (IndexOutOfBoundsException e) {
1513 Logging.trace(e);
1514 Logging.trace("Clearing tagTable selection");
1515 tagTable.clearSelection();
1516 }
1517 }
1518
1519 @Override
1520 public void valueChanged(ListSelectionEvent event) {
1521 removeHiddenSelection();
1522 }
1523
1524 @Override
1525 public void sorterChanged(RowSorterEvent e) {
1526 removeHiddenSelection();
1527 }
1528 }
1529
1530 private final class HoverPreviewPropListener implements ValueChangeListener<Boolean> {
1531 @Override
1532 public void valueChanged(ValueChangeEvent<? extends Boolean> e) {
1533 if (Boolean.TRUE.equals(e.getProperty().get()) && isDialogShowing()) {
1534 MainApplication.getMap().mapView.addPrimitiveHoverListener(PropertiesDialog.this);
1535 } else if (Boolean.FALSE.equals(e.getProperty().get())) {
1536 MainApplication.getMap().mapView.removePrimitiveHoverListener(PropertiesDialog.this);
1537 }
1538 }
1539 }
1540
1541 /*
1542 * Ensure HoverListener is re-added when selection priority is disabled while something is selected.
1543 * Otherwise user would need to change selection to see the preference change take effect.
1544 */
1545 private final class HoverPreviewPreferSelectionPropListener implements ValueChangeListener<Boolean> {
1546 @Override
1547 public void valueChanged(ValueChangeEvent<? extends Boolean> e) {
1548 if (Boolean.FALSE.equals(e.getProperty().get()) &&
1549 Boolean.TRUE.equals(PROP_PREVIEW_ON_HOVER.get()) &&
1550 isDialogShowing()) {
1551 MainApplication.getMap().mapView.addPrimitiveHoverListener(PropertiesDialog.this);
1552 }
1553 }
1554 }
1555}
Note: See TracBrowser for help on using the repository browser.