001// License: GPL. For details, see LICENSE file. 002package org.openstreetmap.josm.data.osm.event; 003 004import java.util.Collections; 005import java.util.HashSet; 006import java.util.List; 007import java.util.Objects; 008import java.util.concurrent.CopyOnWriteArrayList; 009import java.util.stream.Stream; 010 011import org.openstreetmap.josm.data.osm.DataIntegrityProblemException; 012import org.openstreetmap.josm.data.osm.DataSelectionListener; 013import org.openstreetmap.josm.data.osm.DataSet; 014import org.openstreetmap.josm.gui.MainApplication; 015import org.openstreetmap.josm.gui.layer.MainLayerManager; 016import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeEvent; 017import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeListener; 018import org.openstreetmap.josm.gui.util.GuiHelper; 019import org.openstreetmap.josm.tools.bugreport.BugReport; 020import org.openstreetmap.josm.tools.bugreport.ReportedException; 021 022/** 023 * Similar like {@link DatasetEventManager}, just for selection events. 024 * 025 * It allows to register listeners to global selection events for the selection in the current edit layer. 026 * 027 * If you want to listen to selections to a specific data layer, 028 * you can register a listener to that layer by using {@link DataSet#addSelectionListener(DataSelectionListener)} 029 * 030 * @since 2912 031 */ 032public class SelectionEventManager implements DataSelectionListener, ActiveLayerChangeListener { 033 034 private static final SelectionEventManager INSTANCE = new SelectionEventManager(); 035 036 /** 037 * Returns the unique instance. 038 * @return the unique instance 039 */ 040 public static SelectionEventManager getInstance() { 041 return INSTANCE; 042 } 043 044 @FunctionalInterface 045 private interface ListenerInfo { 046 void fire(SelectionChangeEvent event); 047 } 048 049 private static class DataListenerInfo implements ListenerInfo { 050 private final DataSelectionListener listener; 051 052 DataListenerInfo(DataSelectionListener listener) { 053 this.listener = listener; 054 } 055 056 @Override 057 public void fire(SelectionChangeEvent event) { 058 listener.selectionChanged(event); 059 } 060 061 @Override 062 public int hashCode() { 063 return Objects.hash(listener); 064 } 065 066 @Override 067 public boolean equals(Object o) { 068 if (this == o) return true; 069 if (o == null || getClass() != o.getClass()) return false; 070 DataListenerInfo that = (DataListenerInfo) o; 071 return Objects.equals(listener, that.listener); 072 } 073 074 @Override 075 public String toString() { 076 return "DataListenerInfo [listener=" + listener + ']'; 077 } 078 } 079 080 private final CopyOnWriteArrayList<ListenerInfo> inEDTListeners = new CopyOnWriteArrayList<>(); 081 private final CopyOnWriteArrayList<ListenerInfo> immediatelyListeners = new CopyOnWriteArrayList<>(); 082 083 /** 084 * Constructs a new {@code SelectionEventManager}. 085 */ 086 protected SelectionEventManager() { 087 MainLayerManager layerManager = MainApplication.getLayerManager(); 088 // We do not allow for destructing this object. 089 // Currently, this is a singleton class, so this is not required. 090 layerManager.addAndFireActiveLayerChangeListener(this); 091 } 092 093 /** 094 * Adds a selection listener that gets notified for selections immediately. 095 * @param listener The listener to add. 096 * @since 12098 097 */ 098 public void addSelectionListener(DataSelectionListener listener) { 099 immediatelyListeners.addIfAbsent(new DataListenerInfo(listener)); 100 } 101 102 /** 103 * Adds a selection listener that gets notified for selections later in the EDT thread. 104 * Events are sent in the right order but may be delayed. 105 * @param listener The listener to add. 106 * @since 12098 107 */ 108 public void addSelectionListenerForEdt(DataSelectionListener listener) { 109 inEDTListeners.addIfAbsent(new DataListenerInfo(listener)); 110 } 111 112 /** 113 * Unregisters a {@code DataSelectionListener}. 114 * @param listener listener to remove 115 * @since 12098 116 */ 117 public void removeSelectionListener(DataSelectionListener listener) { 118 remove(new DataListenerInfo(listener)); 119 } 120 121 private void remove(ListenerInfo searchListener) { 122 inEDTListeners.remove(searchListener); 123 immediatelyListeners.remove(searchListener); 124 } 125 126 @Override 127 public void activeOrEditLayerChanged(ActiveLayerChangeEvent e) { 128 DataSet oldDataSet = e.getPreviousDataSet(); 129 if (oldDataSet != null) { 130 // Fake a selection removal 131 // Relying on this allows components to not have to monitor layer changes. 132 // If we would not do this, e.g. the move command would have a hard time tracking which layer 133 // the last moved selection was in. 134 selectionChanged(new SelectionReplaceEvent(oldDataSet, 135 new HashSet<>(oldDataSet.getAllSelected()), Stream.empty())); 136 oldDataSet.removeSelectionListener(this); 137 } 138 DataSet newDataSet = e.getSource().getActiveDataSet(); 139 if (newDataSet != null) { 140 newDataSet.addSelectionListener(this); 141 // Fake a selection add 142 selectionChanged(new SelectionReplaceEvent(newDataSet, 143 Collections.emptySet(), newDataSet.getAllSelected().stream())); 144 } 145 } 146 147 @Override 148 public void selectionChanged(SelectionChangeEvent event) { 149 fireEvent(immediatelyListeners, event); 150 try { 151 GuiHelper.runInEDTAndWaitWithException(() -> fireEvent(inEDTListeners, event)); 152 } catch (ReportedException e) { 153 throw BugReport.intercept(e).put("event", event).put("inEDTListeners", inEDTListeners); 154 } 155 } 156 157 private static void fireEvent(List<ListenerInfo> listeners, SelectionChangeEvent event) { 158 for (ListenerInfo listener: listeners) { 159 try { 160 listener.fire(event); 161 } catch (DataIntegrityProblemException e) { 162 throw BugReport.intercept(e).put("event", event).put("listeners", listeners); 163 } 164 } 165 } 166 167 /** 168 * Only to be used during unit tests, to reset the state. Do not use it in plugins/other code. 169 * Called after the layer manager was reset by the test framework. 170 */ 171 public void resetState() { 172 inEDTListeners.clear(); 173 immediatelyListeners.clear(); 174 MainApplication.getLayerManager().addAndFireActiveLayerChangeListener(this); 175 } 176}