Changeset 12048 in josm for trunk/src/org/openstreetmap

Timestamp:

2017-05-03T16:09:46+02:00 (8 years ago)

Author:

michael2402

Message:

Add per-layer selection listeners. Make selection listener code more generic.

Location:

trunk/src/org/openstreetmap/josm

Files:

• actions/SelectNonBranchingWaySequences.java (modified) (1 diff)
• actions/mapmode/SelectAction.java (modified) (1 diff)
• data/osm/DataSelectionListener.java (added)
• data/osm/DataSet.java (modified) (23 diffs)
• data/osm/event/SelectionEventManager.java (modified) (3 diffs)
• gui/dialogs/relation/actions/SavingAction.java (modified) (2 diffs)

trunk/src/org/openstreetmap/josm/actions/SelectNonBranchingWaySequences.java

@@ -160 +160 @@
 
         if (selectionChanged)
-            data.setSelected(selection, true);
+            data.setSelected(selection);
     }
 }

trunk/src/org/openstreetmap/josm/actions/mapmode/SelectAction.java

@@ -850 +850 @@
             if (ctrl) mergePrims(e.getPoint());
         }
-        getLayerManager().getEditDataSet().fireSelectionChanged();
     }
 

trunk/src/org/openstreetmap/josm/data/osm/DataSet.java

@@ -6 +6 @@
 import java.awt.geom.Area;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
@@ -12 +11 @@
 import java.util.HashSet;
 import java.util.Iterator;
-import java.util.LinkedHashSet;
 import java.util.LinkedList;
 import java.util.List;
@@ -22 +20 @@
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import org.openstreetmap.josm.Main;
@@ -33 +33 @@
 import org.openstreetmap.josm.data.coor.EastNorth;
 import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.osm.DataSelectionListener.SelectionAddEvent;
+import org.openstreetmap.josm.data.osm.DataSelectionListener.SelectionChangeEvent;
+import org.openstreetmap.josm.data.osm.DataSelectionListener.SelectionRemoveEvent;
+import org.openstreetmap.josm.data.osm.DataSelectionListener.SelectionReplaceEvent;
+import org.openstreetmap.josm.data.osm.DataSelectionListener.SelectionToggleEvent;
 import org.openstreetmap.josm.data.osm.event.AbstractDatasetChangedEvent;
 import org.openstreetmap.josm.data.osm.event.ChangesetIdChangedEvent;
@@ -42 +47 @@
 import org.openstreetmap.josm.data.osm.event.PrimitivesRemovedEvent;
 import org.openstreetmap.josm.data.osm.event.RelationMembersChangedEvent;
+import org.openstreetmap.josm.data.osm.event.SelectionEventManager;
 import org.openstreetmap.josm.data.osm.event.TagsChangedEvent;
 import org.openstreetmap.josm.data.osm.event.WayNodesChangedEvent;
@@ -167 +173 @@
 
     private final ReadWriteLock lock = new ReentrantReadWriteLock();
+
+    /**
+     * The mutex lock that is used to synchronize selection changes.
+     */
     private final Object selectionLock = new Object();
+    /**
+     * The current selected primitives. This is always a unmodifiable set.
+     */
+    private Set<OsmPrimitive> currentSelectedPrimitives = Collections.emptySet();
+
+    /**
+     * A list of listeners that listen to selection changes on this layer.
+     */
+    private final ListenerList<DataSelectionListener> selectionListeners = ListenerList.create();
 
     private Area cachedDataSourceArea;
@@ -184 +203 @@
         // the listener, projection change listeners are managed as WeakReferences.
         Main.addProjectionChangeListener(this);
+        addSelectionListener((DataSelectionListener) e -> fireDreprecatedSelectionChange(e.getSelection()));
     }
 
@@ -637 +657 @@
             if (!success)
                 throw new JosmRuntimeException("failed to remove primitive: "+primitive);
-            synchronized (selectionLock) {
-                selectedPrimitives.remove(primitive);
-                selectionSnapshot = null;
-            }
+            clearSelection(primitiveId);
             allPrimitives.remove(primitive);
             primitive.setDataset(null);
@@ -654 +671 @@
 
     /**
+     * Add a listener that listens to selection changes in this specific data set.
+     * @param listener The listener.
+     * @see #removeSelectionListener(DataSelectionListener)
+     * @see SelectionEventManager#addSelectionListener(SelectionChangedListener,
+     *      org.openstreetmap.josm.data.osm.event.DatasetEventManager.FireMode)
+     *      To add a global listener.
+     */
+    public void addSelectionListener(DataSelectionListener listener) {
+        selectionListeners.addListener(listener);
+    }
+
+    /**
+     * Remove a listener that listens to selection changes in this specific data set.
+     * @param listener The listener.
+     * @see #addSelectionListener(DataSelectionListener)
+     */
+    public void removeSelectionListener(DataSelectionListener listener) {
+        selectionListeners.removeListener(listener);
+    }
+
+    /*---------------------------------------------------
+     *   OLD SELECTION HANDLING
+     *---------------------------------------------------*/
+
+    /**
      * A list of listeners to selection changed events. The list is static, as listeners register
      * themselves for any dataset selection changes that occur, regardless of the current active
@@ -663 +705 @@
      * Adds a new selection listener.
      * @param listener The selection listener to add
+     * @see #addSelectionListener(DataSelectionListener)
+     * @see SelectionEventManager#removeSelectionListener(SelectionChangedListener)
      */
     public static void addSelectionListener(SelectionChangedListener listener) {
@@ -671 +715 @@
      * Removes a selection listener.
      * @param listener The selection listener to remove
+     * @see #removeSelectionListener(DataSelectionListener)
+     * @see SelectionEventManager#removeSelectionListener(SelectionChangedListener)
      */
     public static void removeSelectionListener(SelectionChangedListener listener) {
@@ -679 +725 @@
      * Notifies all registered {@link SelectionChangedListener} about the current selection in
      * this dataset.
-     *
-     */
+     * @deprecated You should never need to do this from the outside.
+     */
+    @Deprecated
     public void fireSelectionChanged() {
-        Collection<? extends OsmPrimitive> currentSelection = getAllSelected();
+        fireDreprecatedSelectionChange(getAllSelected());
+    }
+
+    private static void fireDreprecatedSelectionChange(Collection<? extends OsmPrimitive> currentSelection) {
         for (SelectionChangedListener l : selListeners) {
             l.selectionChanged(currentSelection);
         }
     }
-
-    private Set<OsmPrimitive> selectedPrimitives = new LinkedHashSet<>();
-    private Collection<OsmPrimitive> selectionSnapshot;
 
     /**
@@ -754 +801 @@
      */
     public Collection<OsmPrimitive> getAllSelected() {
-        Collection<OsmPrimitive> currentList;
-        synchronized (selectionLock) {
-            if (selectionSnapshot == null) {
-                selectionSnapshot = Collections.unmodifiableList(new ArrayList<>(selectedPrimitives));
-            }
-            currentList = selectionSnapshot;
-        }
-        return currentList;
+        return currentSelectedPrimitives;
     }
 
@@ -793 +833 @@
      */
     public boolean selectionEmpty() {
-        return selectedPrimitives.isEmpty();
+        return currentSelectedPrimitives.isEmpty();
     }
 
@@ -802 +842 @@
      */
     public boolean isSelected(OsmPrimitive osm) {
-        return selectedPrimitives.contains(osm);
-    }
-
-    /**
-     * Toggles the selected state of the given collection of primitives.
-     * @param osm The primitives to toggle
-     */
-    public void toggleSelected(Collection<? extends PrimitiveId> osm) {
-        boolean changed = false;
-        synchronized (selectionLock) {
-            for (PrimitiveId o : osm) {
-                changed = changed | this.dotoggleSelected(o);
-            }
-            if (changed) {
-                selectionSnapshot = null;
-            }
-        }
-        if (changed) {
-            fireSelectionChanged();
-        }
-    }
-
-    /**
-     * Toggles the selected state of the given collection of primitives.
-     * @param osm The primitives to toggle
-     */
-    public void toggleSelected(PrimitiveId... osm) {
-        toggleSelected(Arrays.asList(osm));
-    }
-
-    private boolean dotoggleSelected(PrimitiveId primitiveId) {
-        OsmPrimitive primitive = getPrimitiveByIdChecked(primitiveId);
-        if (primitive == null)
-            return false;
-        if (!selectedPrimitives.remove(primitive)) {
-            selectedPrimitives.add(primitive);
-        }
-        selectionSnapshot = null;
-        return true;
+        return currentSelectedPrimitives.contains(osm);
     }
 
@@ -875 +877 @@
      * @param selection the selection
      * @param fireSelectionChangeEvent true, if the selection change listeners are to be notified; false, otherwise
-     */
+     * @deprecated Use {@link #setSelected(Collection)} instead. To bee removed end of 2017. Does not seem to be used by plugins.
+     */
+    @Deprecated
     public void setSelected(Collection<? extends PrimitiveId> selection, boolean fireSelectionChangeEvent) {
-        boolean changed;
-        synchronized (selectionLock) {
-            Set<OsmPrimitive> oldSelection = new LinkedHashSet<>(selectedPrimitives);
-            selectedPrimitives = new LinkedHashSet<>();
-            addSelected(selection, false);
-            changed = !oldSelection.equals(selectedPrimitives);
-            if (changed) {
-                selectionSnapshot = null;
-            }
-        }
-
-        if (changed && fireSelectionChangeEvent) {
-            // If selection is not empty then event was already fired in addSelecteds
-            fireSelectionChanged();
-        }
+        setSelected(selection);
     }
 
@@ -901 +891 @@
      */
     public void setSelected(Collection<? extends PrimitiveId> selection) {
-        setSelected(selection, true /* fire selection change event */);
+        setSelected(selection.stream());
     }
 
@@ -908 +898 @@
      * and notifies all {@link SelectionChangedListener}.
      *
-     * @param osm the primitives to set
+     * @param osm the primitives to set. <code>null</code> values are ignored for now, but this may be removed in the future.
      */
     public void setSelected(PrimitiveId... osm) {
-        if (osm.length == 1 && osm[0] == null) {
-            setSelected();
-            return;
-        }
-        List<PrimitiveId> list = Arrays.asList(osm);
-        setSelected(list);
+        setSelected(Stream.of(osm).filter(Objects::nonNull));
+    }
+
+    private void setSelected(Stream<? extends PrimitiveId> stream) {
+        doSelectionChange(old -> new SelectionReplaceEvent(this, old,
+                stream.map(this::getPrimitiveByIdChecked).filter(Objects::nonNull)));
     }
 
@@ -926 +916 @@
      */
     public void addSelected(Collection<? extends PrimitiveId> selection) {
-        addSelected(selection, true /* fire selection change event */);
+        addSelected(selection.stream());
     }
 
@@ -936 +926 @@
      */
     public void addSelected(PrimitiveId... osm) {
-        addSelected(Arrays.asList(osm));
-    }
-
-    /**
-     * Adds the primitives in <code>selection</code> to the current selection.
-     * Notifies all {@link SelectionChangedListener} if <code>fireSelectionChangeEvent</code> is true.
-     *
-     * @param selection the selection
-     * @param fireSelectionChangeEvent true, if the selection change listeners are to be notified; false, otherwise
-     * @return if the selection was changed in the process
-     */
-    private boolean addSelected(Collection<? extends PrimitiveId> selection, boolean fireSelectionChangeEvent) {
-        boolean changed = false;
-        synchronized (selectionLock) {
-            for (PrimitiveId id: selection) {
-                OsmPrimitive primitive = getPrimitiveByIdChecked(id);
-                if (primitive != null) {
-                    changed = changed | selectedPrimitives.add(primitive);
+        addSelected(Stream.of(osm));
+    }
+
+    private void addSelected(Stream<? extends PrimitiveId> stream) {
+        doSelectionChange(old -> new SelectionAddEvent(this, old,
+                stream.map(this::getPrimitiveByIdChecked).filter(Objects::nonNull)));
+    }
+
+    /**
+     * Removes the selection from every value in the collection.
+     * @param osm The collection of ids to remove the selection from.
+     */
+    public void clearSelection(PrimitiveId... osm) {
+        clearSelection(Stream.of(osm));
+    }
+
+    /**
+     * Removes the selection from every value in the collection.
+     * @param list The collection of ids to remove the selection from.
+     */
+    public void clearSelection(Collection<? extends PrimitiveId> list) {
+        clearSelection(list.stream());
+    }
+
+    /**
+     * Clears the current selection.
+     */
+    public void clearSelection() {
+        setSelected(Stream.empty());
+    }
+
+    private void clearSelection(Stream<? extends PrimitiveId> stream) {
+        doSelectionChange(old -> new SelectionRemoveEvent(this, old,
+                stream.map(this::getPrimitiveByIdChecked).filter(Objects::nonNull)));
+    }
+
+    /**
+     * Toggles the selected state of the given collection of primitives.
+     * @param osm The primitives to toggle
+     */
+    public void toggleSelected(Collection<? extends PrimitiveId> osm) {
+        toggleSelected(osm.stream());
+    }
+
+    /**
+     * Toggles the selected state of the given collection of primitives.
+     * @param osm The primitives to toggle
+     */
+    public void toggleSelected(PrimitiveId... osm) {
+        toggleSelected(Stream.of(osm));
+    }
+
+    private void toggleSelected(Stream<? extends PrimitiveId> stream) {
+        doSelectionChange(old -> new SelectionToggleEvent(this, old,
+                stream.map(this::getPrimitiveByIdChecked).filter(Objects::nonNull)));
+    }
+
+    /**
+     * Do a selection change.
+     * <p>
+     * This is the only method that changes the current selection state.
+     * @param command A generator that generates the {@link SelectionChangeEvent} for the given base set of currently selected primitives.
+     * @return true iff the command did change the selection.
+     * @since 12048
+     */
+    private boolean doSelectionChange(Function<Set<OsmPrimitive>, SelectionChangeEvent> command) {
+        lock.readLock().lock();
+        try {
+            synchronized (selectionLock) {
+                SelectionChangeEvent event = command.apply(currentSelectedPrimitives);
+                if (event.isNop()) {
+                    return false;
                 }
-            }
-            if (changed) {
-                selectionSnapshot = null;
-            }
-        }
-        if (fireSelectionChangeEvent && changed) {
-            fireSelectionChanged();
-        }
-        return changed;
+                currentSelectedPrimitives = event.getSelection();
+                selectionListeners.fireEvent(l -> l.selectionChanged(event));
+                return true;
+            }
+        } finally {
+            lock.readLock().unlock();
+        }
     }
 
@@ -978 +1020 @@
     public void clearHighlightedWaySegments() {
         setHighlightedWaySegments(new ArrayList<WaySegment>());
-    }
-
-    /**
-     * Removes the selection from every value in the collection.
-     * @param osm The collection of ids to remove the selection from.
-     */
-    public void clearSelection(PrimitiveId... osm) {
-        clearSelection(Arrays.asList(osm));
-    }
-
-    /**
-     * Removes the selection from every value in the collection.
-     * @param list The collection of ids to remove the selection from.
-     */
-    public void clearSelection(Collection<? extends PrimitiveId> list) {
-        boolean changed = false;
-        synchronized (selectionLock) {
-            for (PrimitiveId id:list) {
-                OsmPrimitive primitive = getPrimitiveById(id);
-                if (primitive != null) {
-                    changed = changed | selectedPrimitives.remove(primitive);
-                }
-            }
-            if (changed) {
-                selectionSnapshot = null;
-            }
-        }
-        if (changed) {
-            fireSelectionChanged();
-        }
-    }
-
-    /**
-     * Clears the current selection.
-     */
-    public void clearSelection() {
-        if (!selectedPrimitives.isEmpty()) {
-            synchronized (selectionLock) {
-                selectedPrimitives.clear();
-                selectionSnapshot = null;
-            }
-            fireSelectionChanged();
-        }
     }
 
@@ -1372 +1371 @@
         beginUpdate();
         try {
-            boolean changed = cleanupDeleted(nodes.iterator());
-            if (cleanupDeleted(ways.iterator())) {
-                changed = true;
-            }
-            if (cleanupDeleted(relations.iterator())) {
-                changed = true;
-            }
-            if (changed) {
-                fireSelectionChanged();
-            }
+            cleanupDeleted(Stream.concat(
+                    nodes.stream(), Stream.concat(ways.stream(), relations.stream())));
         } finally {
             endUpdate();
@@ -1387 +1378 @@
     }
 
-    private boolean cleanupDeleted(Iterator<? extends OsmPrimitive> it) {
-        boolean changed = false;
-        synchronized (selectionLock) {
-            while (it.hasNext()) {
-                OsmPrimitive primitive = it.next();
-                if (primitive.isDeleted() && (!primitive.isVisible() || primitive.isNew())) {
-                    selectedPrimitives.remove(primitive);
-                    selectionSnapshot = null;
-                    allPrimitives.remove(primitive);
-                    primitive.setDataset(null);
-                    changed = true;
-                    it.remove();
-                }
-            }
-            if (changed) {
-                selectionSnapshot = null;
-            }
-        }
-        return changed;
+    private void cleanupDeleted(Stream<? extends OsmPrimitive> it) {
+        clearSelection(it
+                .filter(primitive -> primitive.isDeleted() && (!primitive.isVisible() || primitive.isNew()))
+                .peek(allPrimitives::remove)
+                .peek(primitive -> primitive.setDataset(null)));
     }
 

trunk/src/org/openstreetmap/josm/data/osm/event/SelectionEventManager.java

@@ -3 +3 @@
 
 import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Objects;
+import java.util.Set;
 import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.stream.Stream;
 
 import javax.swing.SwingUtilities;
 
+import org.openstreetmap.josm.Main;
 import org.openstreetmap.josm.data.SelectionChangedListener;
+import org.openstreetmap.josm.data.osm.DataSelectionListener;
 import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.osm.event.DatasetEventManager.FireMode;
+import org.openstreetmap.josm.gui.layer.MainLayerManager;
+import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeEvent;
+import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeListener;
 
 /**
- * Similar like {@link DatasetEventManager}, just for selection events. Because currently selection changed
- * event are global, only FIRE_IN_EDT and FIRE_EDT_CONSOLIDATED modes are really useful
+ * Similar like {@link DatasetEventManager}, just for selection events.
+ *
+ * It allows to register listeners to global selection events for the selection in the current edit layer.
+ *
+ * If you want to listen to selections to a specific data layer,
+ * you can register a listener to that layer by using {@link DataSet#addSelectionListener(DataSelectionListener)}
+ *
  * @since 2912
  */
-public class SelectionEventManager implements SelectionChangedListener {
+public class SelectionEventManager implements DataSelectionListener, ActiveLayerChangeListener {
 
     private static final SelectionEventManager instance = new SelectionEventManager();
@@ -59 +73 @@
      * Constructs a new {@code SelectionEventManager}.
      */
-    public SelectionEventManager() {
-        DataSet.addSelectionListener(this);
+    protected SelectionEventManager() {
+        MainLayerManager layerManager = Main.getLayerManager();
+        // We do not allow for destructing this object.
+        // Currently, this is a singleton class, so this is not required.
+        layerManager.addAndFireActiveLayerChangeListener(this);
     }
 
@@ -89 +106 @@
 
     @Override
-    public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
+    public void activeOrEditLayerChanged(ActiveLayerChangeEvent e) {
+        DataSet oldDataSet = e.getPreviousEditDataSet();
+        if (oldDataSet != null) {
+            // Fake a selection removal
+            // Relying on this allows components to not have to monitor layer changes.
+            // If we would not do this, e.g. the move command would have a hard time tracking which layer
+            // the last moved selection was in.
+            SelectionReplaceEvent event = new SelectionReplaceEvent(oldDataSet,
+                    new HashSet<>(oldDataSet.getAllSelected()), Stream.empty());
+            selectionChanged(event);
+            oldDataSet.removeSelectionListener(this);
+        }
+        DataSet newDataSet = e.getSource().getEditDataSet();
+        if (newDataSet != null) {
+            newDataSet.addSelectionListener(this);
+            // Fake a selection add
+            SelectionReplaceEvent event = new SelectionReplaceEvent(newDataSet,
+                    Collections.emptySet(), newDataSet.getAllSelected().stream());
+            selectionChanged(event);
+        }
+    }
+
+    @Override
+    public void selectionChanged(SelectionChangeEvent e) {
+        Set<OsmPrimitive> newSelection = e.getSelection();
         fireEvents(normalListeners, newSelection);
         selection = newSelection;

trunk/src/org/openstreetmap/josm/gui/dialogs/relation/actions/SavingAction.java

@@ -76 +76 @@
         // make sure everybody is notified about the changes
         //
-        layer.data.fireSelectionChanged();
         editor.setRelation(newRelation);
         if (editor instanceof RelationEditor) {
@@ -108 +107 @@
         if (!editedRelation.hasEqualSemanticAttributes(editor.getRelation(), false)) {
             Main.main.undoRedo.add(new ChangeCommand(editor.getRelation(), editedRelation));
-            layer.data.fireSelectionChanged();
         }
     }