Changeset 3550 in josm for trunk/src/org

Timestamp:

2010-09-19T23:43:49+02:00 (14 years ago)

Author:

bastiK

Message:

see #5457 (patch by Christian Müller) - make it easier to select ways and nodes, if there are multiple primitives under the cursor

File:

• trunk/src/org/openstreetmap/josm/actions/mapmode/SelectAction.java (modified) (12 diffs)

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

@@ -16 +16 @@
 import java.util.Collections;
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.LinkedList;
-import java.util.List;
 import java.util.Set;
 import java.util.TreeSet;
@@ -203 +203 @@
                     virtualWays.size());
             Main.main.undoRedo.add(new SequenceCommand(text, virtualCmds));
-            selectPrims(Collections.singleton((OsmPrimitive)virtualNode), false, false, false, false);
+            getCurrentDataSet().setSelected(Collections.singleton((OsmPrimitive)virtualNode));
             virtualWays.clear();
             virtualNode = null;
@@ -269 +269 @@
     }
 
-    private Collection<OsmPrimitive> getNearestCollectionVirtual(Point p, boolean allSegements) {
+    private Collection<OsmPrimitive> getNearestCollectionVirtual(Point p) {
+        int snapDistance = Main.pref.getInteger("mappaint.node.virtual-snap-distance", 8);
+        int virtualSpace = Main.pref.getInteger("mappaint.node.virtual-space", 70);
+        snapDistance *= snapDistance;
+
         MapView c = Main.map.mapView;
-        int snapDistance = Main.pref.getInteger("mappaint.node.virtual-snap-distance", 8);
-        snapDistance *= snapDistance;
+
+        Collection<OsmPrimitive> sel = getCurrentDataSet().getSelected();
         OsmPrimitive osm = c.getNearestNode(p, OsmPrimitive.isSelectablePredicate);
-        virtualWays.clear();
-        virtualNode = null;
-        Node virtualWayNode = null;
-
-        if (osm == null)
-        {
-            Collection<WaySegment> nearestWaySegs = allSegements
-            ? c.getNearestWaySegments(p, OsmPrimitive.isSelectablePredicate)
-                    : Collections.singleton(c.getNearestWaySegment(p, OsmPrimitive.isSelectablePredicate));
-
-            for(WaySegment nearestWS : nearestWaySegs) {
+
+        if (osm != null) {
+            for (Node n : c.getNearestNodes(p, OsmPrimitive.isSelectablePredicate)) {
+                if (sel.contains(n)) {
+                    osm = n;
+                }
+            }
+        } else {
+            Node virtualWayNode = null;
+            Way w = null;
+
+            Collection<WaySegment> virtualWaysInSel = new ArrayList<WaySegment>();
+            osm = c.getNearestWay(p, OsmPrimitive.isSelectablePredicate);
+
+            for(WaySegment nearestWS : c.getNearestWaySegments(p, OsmPrimitive.isSelectablePredicate)) {
                 if (nearestWS == null) {
                     continue;
                 }
-
-                osm = nearestWS.way;
-                if(Main.pref.getInteger("mappaint.node.virtual-size", 8) > 0)
-                {
-                    Way w = (Way)osm;
+                if (sel.contains(w = nearestWS.way)) {
+                    osm = w;
+                }
+
+                if (Main.pref.getInteger("mappaint.node.virtual-size", 8) > 0) {
                     Point p1 = c.getPoint(w.getNode(nearestWS.lowerIndex));
                     Point p2 = c.getPoint(w.getNode(nearestWS.lowerIndex+1));
-                    if(SimplePaintVisitor.isLargeSegment(p1, p2, Main.pref.getInteger("mappaint.node.virtual-space", 70)))
+                    if(SimplePaintVisitor.isLargeSegment(p1, p2, virtualSpace))
                     {
                         Point pc = new Point((p1.x+p2.x)/2, (p1.y+p2.y)/2);
@@ -304 +312 @@
                             // virtual node at the same spot will be joined which is likely unwanted
                             if(virtualWayNode != null) {
-                                if(  !w.getNode(nearestWS.lowerIndex+1).equals(virtualWayNode)
+                                if(!w.getNode(nearestWS.lowerIndex+1).equals(virtualWayNode)
                                         && !w.getNode(nearestWS.lowerIndex).equals(virtualWayNode)) {
                                     continue;
@@ -312 +320 @@
                             }
 
-                            virtualWays.add(nearestWS);
+                            (!sel.contains(w) ? virtualWays : virtualWaysInSel).add(nearestWS);
                             if(virtualNode == null) {
                                 virtualNode = new Node(Main.map.mapView.getLatLon(pc.x, pc.y));
@@ -320 +328 @@
                 }
             }
-        }
+
+            if (virtualNode != null) {
+                virtualWays = virtualWaysInSel.isEmpty() ? virtualWays : virtualWaysInSel;
+                osm = virtualWays.iterator().next().way;
+            }
+        }
+
         if (osm == null)
             return Collections.emptySet();
@@ -338 +352 @@
         if(!Main.map.mapView.isActiveLayerVisible())
             return;
+
         // request focus in order to enable the expected keyboard shortcuts
-        //
         Main.map.mapView.requestFocus();
 
@@ -347 +361 @@
             return;
         boolean ctrl = (e.getModifiers() & ActionEvent.CTRL_MASK) != 0;
-        boolean alt = (e.getModifiers() & (ActionEvent.ALT_MASK|InputEvent.ALT_GRAPH_MASK)) != 0;
         boolean shift = (e.getModifiers() & ActionEvent.SHIFT_MASK) != 0;
 
@@ -360 +373 @@
         initialMoveThresholdExceeded = false;
 
-        Collection<OsmPrimitive> osmColl = getNearestCollectionVirtual(e.getPoint(), alt);
+        Collection<OsmPrimitive> osmColl = getNearestCollectionVirtual(e.getPoint());
 
         if (ctrl && shift) {
@@ -383 +396 @@
             selectionManager.mousePressed(e);
         }
-        if(mode != Mode.move || shift || ctrl)
-        {
+
+        if(mode != Mode.move || shift || ctrl) {
             virtualNode = null;
             virtualWays.clear();
@@ -421 +434 @@
             boolean ctrl = (e.getModifiers() & ActionEvent.CTRL_MASK) != 0;
             boolean shift = (e.getModifiers() & ActionEvent.SHIFT_MASK) != 0;
+            boolean alt = (e.getModifiers() & (ActionEvent.ALT_MASK|InputEvent.ALT_GRAPH_MASK)) != 0
+                            || Main.pref.getBoolean("selectaction.rotates", false);
+
+            virtualWays.clear();
+            virtualNode = null;
+
             if (!didMove) {
-                selectPrims(
-                        Main.map.mapView.getNearestCollection(e.getPoint(), OsmPrimitive.isSelectablePredicate),
-                        shift, ctrl, true, false);
+                Collection<OsmPrimitive> c = Main.map.mapView.getNearestCollection(e.getPoint(), OsmPrimitive.isSelectablePredicate);
+                if (!c.isEmpty() && alt) {
+                    if (c.iterator().next() instanceof Node) {
+                        // there is at least one node under the cursor:
+                        //   - make sure (first element of new list) equals (result of getNearestCollection)
+                        //   - do not consider ways at all, but all nearest nodes
+                        c = new ArrayList<OsmPrimitive>(Main.map.mapView.getNearestNodes(e.getPoint(), OsmPrimitive.isSelectablePredicate));
+                    } else {
+                        // consider all ways..
+                        c = Main.map.mapView.getAllNearest(e.getPoint(), OsmPrimitive.isSelectablePredicate);
+                    }
+                }
+                selectPrims(c, shift, ctrl, true, false);
 
                 // If the user double-clicked a node, change to draw mode
-                List<OsmPrimitive> sel = new ArrayList<OsmPrimitive>(getCurrentDataSet().getSelected());
-                if(e.getClickCount() >=2 && sel.size() == 1 && sel.get(0) instanceof Node) {
+                c = getCurrentDataSet().getSelected();
+                if(e.getClickCount() >=2 && c.size() == 1 && c.iterator().next() instanceof Node) {
                     // We need to do it like this as otherwise drawAction will see a double
                     // click and switch back to SelectMode
@@ -501 +530 @@
     }
 
+    private boolean selMorePrims = false;
+    private OsmPrimitive selCycleStart = null;
+
     public void selectPrims(Collection<OsmPrimitive> selectionList, boolean shift,
             boolean ctrl, boolean released, boolean area) {
         DataSet ds = getCurrentDataSet();
-        if ((shift && ctrl) || (ctrl && !released))
+        if ((shift && ctrl) || (ctrl && !released) || (!virtualWays.isEmpty()))
             return; // not allowed together
+
+        // toggle through possible objects on mouse release
+        if (released && !area) {
+            if (selectionList.size() > 1) {
+                Collection<OsmPrimitive> coll = ds.getSelected();
+
+                OsmPrimitive first, foundInDS, node, nxt;
+                first = nxt = selectionList.iterator().next();
+                foundInDS = node = null;
+
+                for (Iterator<OsmPrimitive> i = selectionList.iterator(); i.hasNext(); ) {
+                    if (selMorePrims && shift) {
+                        if (!coll.contains(nxt = i.next())) {
+                            break; // take first primitive not in dsSel or last if all contained
+                        }
+                    } else {
+                        if (coll.contains(nxt = i.next())) {
+                            foundInDS = nxt;
+                            if (selMorePrims || ctrl) {
+                                ds.clearSelection(nxt);
+                                nxt = i.hasNext() ? i.next() : first;
+                            }
+                            break; // take next primitive of selList
+                        } else if (nxt instanceof Node && node == null) {
+                            node = nxt;
+                        }
+                    }
+                }
+
+                if (ctrl) {
+                    if (foundInDS != null) {
+                        // a member of selList was foundInDS
+                        if (!selectionList.contains(selCycleStart)) {
+                            selCycleStart = foundInDS;
+                        }
+                        // check if selCycleStart == prim (equals next(foundInDS))
+                        if (selCycleStart.equals(nxt)) {
+                            ds.addSelected(nxt);   // cycle complete, prim toggled below
+                            selCycleStart = null;  // check: might do w/out ??
+                        }
+                    } else {
+                        // no member of selList was foundInDS (sets were disjunct), setup for new cycle
+                        selCycleStart = nxt = (node != null) ? node : first;
+                    }
+                }
+
+                selectionList = new ArrayList<OsmPrimitive>(1); // do not modify the passed object..
+                selectionList.add(nxt);
+            }
+        }
+
+        // hard-wiring to false due to performance reasons, should do w/out
+        selMorePrims = (released || area) ? false : ds.getSelected().containsAll(selectionList);
 
         if (ctrl) {