Changeset 329 in josm for branch/0.5/src/org/openstreetmap/josm/actions/mapmode

Timestamp:

2007-09-24T01:36:24+02:00 (18 years ago)

Author:

framm

Message:

This commit is a manual merge of all changes that have been made to
the intermediate "core_0.5" branch on the main OSM repository,
bevore JOSM was moved to openstreetmap.de.

Changes incorporated here:

r4464@svn.openstreetmap.org
r4466@svn.openstreetmap.org
r4468@svn.openstreetmap.org
r4469@svn.openstreetmap.org
r4479@svn.openstreetmap.org

Location:

branch/0.5/src/org/openstreetmap/josm/actions/mapmode

Files:

• AddNodeAction.java (modified) (13 diffs)
• AddSegmentAction.java (modified) (7 diffs)
• AddWayAction.java (modified) (1 diff)
• DeleteAction.java (modified) (8 diffs)
• MapMode.java (modified) (1 diff)
• MoveAction.java (modified) (1 diff)
• SelectionAction.java (modified) (6 diffs)

branch/0.5/src/org/openstreetmap/josm/actions/mapmode/AddNodeAction.java

@@ -24 +24 @@
 import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
-import org.openstreetmap.josm.data.osm.Segment;
 import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.data.osm.WaySegment;
 import org.openstreetmap.josm.gui.MapFrame;
 import org.openstreetmap.josm.tools.ImageProvider;
@@ -33 +33 @@
  * and there is it. Nothing more, nothing less.
  *
+ * FIXME: "nothing more, nothing less" is a bit out-of-date
+ *
  * Newly created nodes are selected. Shift modifier does not cancel the old
  * selection as usual.
@@ -41 +43 @@
 public class AddNodeAction extends MapMode {
 
-        enum Mode {node, nodesegment, autonode}
+        enum Mode {node, nodeway, autonode}
         private final Mode mode;
 
@@ -49 +51 @@
                         putValue("help", "Action/AddNode");
                         actions.add(new AddNodeAction(mf,tr("Add node"), Mode.node, tr("Add a new node to the map")));
-                        actions.add(new AddNodeAction(mf, tr("Add node into segment"), Mode.nodesegment,tr( "Add a node into an existing segment")));
-                        actions.add(new AddNodeAction(mf, tr("Add node and connect"), Mode.autonode,tr( "Add a node and connect it to the selected node (with CTRL: add node into segment; with SHIFT: re-use existing node)")));
+                        actions.add(new AddNodeAction(mf, tr("Add node into way"), Mode.nodeway,tr( "Add a node into an existing way")));
+                        actions.add(new AddNodeAction(mf, tr("Add node and connect"), Mode.autonode,tr( "Add a node and connect it to the selected node (with CTRL: add node into way; with SHIFT: re-use existing node)")));
                         setCurrent(0);
                 }
@@ -83 +85 @@
          * position.
          *
-         * If in nodesegment mode, add the node to the line segment by splitting the
-         * segment. The new created segment will be inserted in every way the segment
-         * was part of.
+         * If in nodeway mode, insert the node into the way. 
          */
         @Override public void mouseClicked(MouseEvent e) {
@@ -98 +98 @@
 
                 Command c = new AddCommand(n);
-                if (mode == Mode.nodesegment) {
-                        Segment s = Main.map.mapView.getNearestSegment(e.getPoint());
-                        if (s == null)
+                if (mode == Mode.nodeway) {
+                        WaySegment ws = Main.map.mapView.getNearestWaySegment(e.getPoint());
+                        if (ws == null)
                                 return;
                         
                         // see if another segment is also near
-                        Segment other = Main.map.mapView.getNearestSegment(e.getPoint(), Collections.singleton(s));
+                        WaySegment other = Main.map.mapView.getNearestWaySegment(e.getPoint(),
+                                Collections.singleton(ws));
+
+                        Node n1 = ws.way.nodes.get(ws.lowerIndex),
+                                n2 = ws.way.nodes.get(ws.lowerIndex + 1);
 
                         if (other == null && (e.getModifiersEx() & MouseEvent.ALT_DOWN_MASK) == 0) {
                                 // moving the new point to the perpendicular point
-                                // FIXME: when two segments are split, should move the new point to the
+                                // FIXME: when two way segments are split, should move the new point to the
                                 // intersection point!
-                                EastNorth A = s.from.eastNorth;
-                                EastNorth B = s.to.eastNorth;
+                                EastNorth A = n1.eastNorth;
+                                EastNorth B = n2.eastNorth;
                                 double ab = A.distance(B);
                                 double nb = n.eastNorth.distance(B);
@@ -124 +128 @@
                         
                         // split the first segment
-                        splitSegmentAtNode(s, n, cmds);
+                        splitWaySegmentAtNode(ws, n, cmds);
                         
                         // if a second segment was found, split that as well
-                        if (other != null) splitSegmentAtNode(other, n, cmds);
+                        if (other != null) splitWaySegmentAtNode(other, n, cmds);
 
                         c = new SequenceCommand(tr((other == null) ? 
-                                "Add node into segment" : "Add common node into two segments"), cmds);
+                                "Add node into way" : "Add common node into two ways"), cmds);
                 }
 
@@ -136 +140 @@
                 if (mode == Mode.autonode) {
 
-                        Segment insertInto = null;
+                        WaySegment insertInto = null;
                         Node reuseNode = null;
                         
-                        // If CTRL is held, insert the node into a potentially existing segment
+                        // If CTRL is held, insert the node into a potentially existing way segment
                         if ((e.getModifiersEx() & MouseEvent.CTRL_DOWN_MASK) != 0) {
-                                insertInto = Main.map.mapView.getNearestSegment(e.getPoint());
+                                insertInto = Main.map.mapView.getNearestWaySegment(e.getPoint());
+                                if (insertInto == null) System.err.println("Couldn't find nearby way segment");
                                 if (insertInto == null)
                                         return;
@@ -150 +155 @@
                         // continuation of the "add node and connect" stuff)
                         else if ((e.getModifiersEx() & MouseEvent.SHIFT_DOWN_MASK) != 0) {
-                                OsmPrimitive clicked = Main.map.mapView.getNearest(e.getPoint(), false);
+                                OsmPrimitive clicked = Main.map.mapView.getNearest(e.getPoint());
                                 if (clicked == null || !(clicked instanceof Node))
                                         return;
@@ -159 +164 @@
                         if (selection.size() == 1 && selection.iterator().next() instanceof Node) {
                                 Node n1 = (Node)selection.iterator().next();
+
                                 Collection<Command> cmds = new LinkedList<Command>();
                                 
                                 if (reuseNode != null) {
                                         // in re-use node mode, n1 must not be identical to clicked node
+                                        if (n1 == reuseNode) System.err.println("n1 == reuseNode");
                                         if (n1 == reuseNode) return;
                                         // replace newly created node with existing node
@@ -171 +178 @@
                                 }
                                 
-                                Segment s = new Segment(n1, n);
-                                
+                                /* Keep track of the way we change, it might be the same into
+                                 * which we insert the node.
+                                 */
+                                Way newInsertInto = null;
                                 if (insertInto != null)
-                                        splitSegmentAtNode(insertInto, n, cmds);
-                                
-                                cmds.add(new AddCommand(s));                    
+                                        newInsertInto = splitWaySegmentAtNode(insertInto, n, cmds);
 
                                 Way way = getWayForNode(n1);
-                                if (way != null) {
-                                        Way newWay = new Way(way);
-                                        if (way.segments.get(0).from == n1) {
-                                                Node tmp = s.from;
-                                                s.from = s.to;
-                                                s.to = tmp;
-                                                newWay.segments.add(0, s);
-                                        } else
-                                                newWay.segments.add(s);
-                                        cmds.add(new ChangeCommand(way, newWay));
-                                }
-
-                                c = new SequenceCommand(tr((insertInto == null) ? "Add node and connect" : "Add node into segment and connect"), cmds);
+                                if (way == null) {
+                                        way = new Way();
+                                        way.nodes.add(n1);
+                                        cmds.add(new AddCommand(way));
+                                } else {
+                                        if (insertInto != null && way == insertInto.way) {
+                                                way = newInsertInto;
+                                        } else {
+                                                Way wnew = new Way(way);
+                                                cmds.add(new ChangeCommand(way, wnew));
+                                                way = wnew;
+                                        }
+                                }
+
+                                if (way.nodes.get(way.nodes.size() - 1) == n1) {
+                                        way.nodes.add(n);
+                                } else {
+                                        way.nodes.add(0, n);
+                                }
+
+                                c = new SequenceCommand(tr((insertInto == null) ? "Add node and connect" : "Add node into way and connect"), cmds);
                         }       
                 }               
@@ -201 +216 @@
         
         /**
-         * @return If the node is part of exactly one way, return this. 
+         * @return If the node is the end of exactly one way, return this. 
          *      <code>null</code> otherwise.
          */
@@ -207 +222 @@
                 Way way = null;
                 for (Way w : Main.ds.ways) {
-                        for (Segment s : w.segments) {
-                                if (s.from == n || s.to == n) {
+                        int i = w.nodes.indexOf(n);
+                        if (i == -1) continue;
+                        if (i == 0 || i == w.nodes.size() - 1) {
                                         if (way != null)
                                                 return null;
-                                        if (s.from == s.to)
-                                                return null;
                                         way = w;
                                 }
                         }
-                }
                 return way;
         }
         
-        private void splitSegmentAtNode(Segment s, Node n, Collection<Command> cmds) {
-                Segment s1 = new Segment(s);
-                s1.to = n;
-                Segment s2 = new Segment(s.from, s.to);
-                s2.from = n;
-                if (s.keys != null)
-                        s2.keys = new HashMap<String, String>(s.keys);
-
-                cmds.add(new ChangeCommand(s, s1));
-                cmds.add(new AddCommand(s2));
-
-                // Add the segment to every way
-                for (Way wold : Main.ds.ways) {
-                        if (wold.segments.contains(s)) {
-                                Way wnew = new Way(wold);
-                                Collection<Segment> segs = new ArrayList<Segment>(wnew.segments);
-                                wnew.segments.clear();
-                                for (Segment waySeg : segs) {
-                                        wnew.segments.add(waySeg);
-                                        if (waySeg == s)
-                                                wnew.segments.add(s2);
-                                }
-                                cmds.add(new ChangeCommand(wold, wnew));
-                        }
-                }
+        private Way splitWaySegmentAtNode(WaySegment ws, Node n, Collection<Command> cmds) {
+                Way wnew = new Way(ws.way);
+                wnew.nodes.add(ws.lowerIndex + 1, n);
+                cmds.add(new ChangeCommand(ws.way, wnew));
+                return wnew;
         }
 }

branch/0.5/src/org/openstreetmap/josm/actions/mapmode/AddSegmentAction.java

@@ -15 +15 @@
 import org.openstreetmap.josm.Main;
 import org.openstreetmap.josm.command.AddCommand;
+import org.openstreetmap.josm.command.ChangeCommand;
 import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
-import org.openstreetmap.josm.data.osm.Segment;
+import org.openstreetmap.josm.data.osm.Way;
 import org.openstreetmap.josm.gui.MapFrame;
 import org.openstreetmap.josm.tools.ImageProvider;
@@ -51 +52 @@
          */
         public AddSegmentAction(MapFrame mapFrame) {
-                super(tr("Add segment"), 
+                super(tr("Connect two nodes"), 
                                 "addsegment", 
-                                tr("Add a segment between two nodes."), 
+                                tr("Connect two nodes using ways."), 
                                 KeyEvent.VK_G, 
                                 mapFrame, 
@@ -72 +73 @@
         }
 
-        
+        /**
+         * Called when user hits space bar while dragging.
+         */
         @Override public void actionPerformed(ActionEvent e) {
                 super.actionPerformed(e);
@@ -85 +88 @@
                         return;
 
-                OsmPrimitive clicked = Main.map.mapView.getNearest(e.getPoint(), true);
-                if (clicked == null || !(clicked instanceof Node))
-                        return;
+                Node clicked = Main.map.mapView.getNearestNode(e.getPoint());
+                if (clicked == null) return;
 
                 drawHint(false);
-                first = second = (Node)clicked;
+                first = second = clicked;
         }
 
@@ -101 +103 @@
                         return;
 
-                OsmPrimitive clicked = Main.map.mapView.getNearest(e.getPoint(), (e.getModifiersEx() & MouseEvent.ALT_DOWN_MASK) != 0);
-                if (clicked == null || clicked == second || !(clicked instanceof Node))
-                        return;
+                Node hovered = Main.map.mapView.getNearestNode(e.getPoint());
+                if (hovered == second) return;
 
                 drawHint(false);
-
-                second = (Node)clicked;
+                second = hovered;
                 drawHint(true);
         }
@@ -116 +116 @@
         @Override public void mouseReleased(MouseEvent e) {
                 if (e.getButton() == MouseEvent.BUTTON1) {
+                        drawHint(false);
                         makeSegment();
-                        first = null; // release segment drawing
+                        first = null;
                 }
+        }
+
+        /**
+         * @return If the node is the end of exactly one way, return this. 
+         *      <code>null</code> otherwise.
+         */
+        private Way getWayForNode(Node n) {
+                Way way = null;
+                for (Way w : Main.ds.ways) {
+                        int i = w.nodes.indexOf(n);
+                        if (i == -1) continue;
+                        if (i == 0 || i == w.nodes.size() - 1) {
+                                if (way != null)
+                                        return null;
+                                way = w;
+                        }
+                }
+                return way;
         }
 
@@ -126 +145 @@
          */
         private void makeSegment() {
-                if (first == null || second == null) {
-                        first = null;
-                        second = null;
-                        return;
-                }
-
-                drawHint(false);
+                Node n1 = first;
+                Node n2 = second;
                 
-                Node start = first;
-                Node end = second;
+                // this is to allow continued segment drawing by hitting the space bar
+                // at every intermediate node
                 first = second;
                 second = null;
+
+                if (n1 == null || n2 == null || n1 == n2) return;
+
+                Way w = getWayForNode(n1);
+                Way wnew;
+                Collection<OsmPrimitive> sel = Main.ds.getSelected();
                 
-                if (start != end) {
-                        // try to find a segment
-                        for (Segment ls : Main.ds.segments)
-                                if (!ls.deleted && ((start == ls.from && end == ls.to) || (end == ls.from && start == ls.to)))
-                                        return; // already a segment here - be happy, do nothing.
-
-                        Segment ls = new Segment(start, end);
-                        Main.main.undoRedo.add(new AddCommand(ls));
-                        Collection<OsmPrimitive> sel = Main.ds.getSelected();
-                        sel.add(ls);
+                if (w == null) {
+                        // create a new way and add it to the current selection.
+                        wnew = new Way();
+                        wnew.nodes.add(n1);
+                        wnew.nodes.add(n2);
+                        Main.main.undoRedo.add(new AddCommand(wnew));
+                        sel.add(wnew);
+                        Main.ds.setSelected(sel);
+                } else {
+                        // extend an existing way; only add to current selection if
+                        // it is not already in there.
+                        wnew = new Way(w);
+                        if (wnew.nodes.get(wnew.nodes.size() - 1) == n1) {
+                                wnew.nodes.add(n2);
+                        } else {
+                                wnew.nodes.add(0, n2);
+                        }
+                        Main.main.undoRedo.add(new ChangeCommand(w, wnew));
+                        // do not use wnew below; ChangeCommand only uses wnew as a
+                        // message about changes to be done to w but will not replace w!
+                        if (!sel.contains(w)) {
+                                sel.add(w);
+                        }
+                        // do not move this into the if block above since it also
+                        // fires the selection change event which is desired.
                         Main.ds.setSelected(sel);
                 }

branch/0.5/src/org/openstreetmap/josm/actions/mapmode/AddWayAction.java

@@ -1 @@
-// License: GPL. Copyright 2007 by Immanuel Scholz and others
-package org.openstreetmap.josm.actions.mapmode;
-
-import static org.openstreetmap.josm.tools.I18n.tr;
-import static org.openstreetmap.josm.tools.I18n.trn;
-
-import java.awt.event.KeyEvent;
-import java.awt.event.MouseEvent;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.LinkedList;
-
-import javax.swing.JOptionPane;
-
-import org.openstreetmap.josm.Main;
-import org.openstreetmap.josm.actions.ReorderAction;
-import org.openstreetmap.josm.command.AddCommand;
-import org.openstreetmap.josm.command.ChangeCommand;
-import org.openstreetmap.josm.command.DeleteCommand;
-import org.openstreetmap.josm.data.SelectionChangedListener;
-import org.openstreetmap.josm.data.osm.DataSet;
-import org.openstreetmap.josm.data.osm.OsmPrimitive;
-import org.openstreetmap.josm.data.osm.Segment;
-import org.openstreetmap.josm.data.osm.Way;
-import org.openstreetmap.josm.gui.MapFrame;
-import org.openstreetmap.josm.tools.ImageProvider;
-
-/**
- * Add a new way. The action is split into the first phase, where a new way get
- * created or selected and the second, where this way is modified.
- *
- * Way creation mode:
- * If there is a selection when the mode is entered, all segments in this
- * selection form a new way. All non-segment objects are deselected. If there
- * were ways selected, the user is asked whether to select all segments of these
- * ways or not, except there is exactly one way selected, which enter the
- * edit ways mode for this way immediatly.
- * 
- * If there is no selection on entering, and the user clicks on an segment, 
- * the way editing starts the with a new way and this segment. If the user click
- * on a way (not holding Alt down), then this way is edited in the way edit mode.
- *
- * Way editing mode:
- * The user can click on subsequent segments. If the segment belonged to the way
- * it get removed from the way. Elsewhere it get added to the way. JOSM try to add
- * the segment in the correct position. This is done by searching for connections
- * to the segment at its 'to' node which are also in the way. The segemnt is 
- * inserted in the way as predecessor of the found segment (or at last segment, if
- * nothing found). 
- *
- * @author imi
- */
-public class AddWayAction extends MapMode implements SelectionChangedListener {
-        private Way way;
-
-        /**
-         * Create a new AddWayAction.
-         * @param mapFrame The MapFrame this action belongs to.
-         * @param followMode The mode to go into when finished creating a way.
-         */
-        public AddWayAction(MapFrame mapFrame) {
-                super(tr("Add Way"), "addway", tr("Add a new way to the data."), KeyEvent.VK_W, mapFrame, ImageProvider.getCursor("normal", "way"));
-                DataSet.listeners.add(this);
-        }
-
-        @Override public void enterMode() {
-                super.enterMode();
-                way = makeWay();
-                Main.ds.setSelected(way);
-                Main.map.mapView.addMouseListener(this);
-        }
-
-        @Override public void exitMode() {
-                super.exitMode();
-                way = null;
-                Main.map.mapView.removeMouseListener(this);
-        }
-
-        @Override public void mouseClicked(MouseEvent e) {
-                if (e.getButton() != MouseEvent.BUTTON1)
-                        return;
-
-                Segment s = Main.map.mapView.getNearestSegment(e.getPoint());
-                if (s == null)
-                        return;
-
-                // special case for initial selecting one way
-                if (way == null && (e.getModifiers() & MouseEvent.ALT_DOWN_MASK) == 0) {
-                        Way w = Main.map.mapView.getNearestWay(e.getPoint());
-                        if (w != null) {
-                                way = w;
-                                Main.ds.setSelected(way);
-                                for (Segment seg : way.segments) {
-                                        if (seg.incomplete) {
-                                                JOptionPane.showMessageDialog(Main.parent,tr("Warning: This way is incomplete. Try to download it before adding segments."));
-                                                return;
-                                        }
-                                }
-                                return;
-                        }
-                }
-
-                if (way != null && way.segments.contains(s)) {
-                        Way copy = new Way(way);
-
-                        copy.segments.remove(s);
-                        if (copy.segments.isEmpty()) {
-                                Main.main.undoRedo.add(new DeleteCommand(Arrays.asList(new OsmPrimitive[]{way})));
-                                way = null;
-                        } else
-                                Main.main.undoRedo.add(new ChangeCommand(way, copy));
-                } else {
-                        if (way == null) {
-                                way = new Way();
-                                way.segments.add(s);
-                                Main.main.undoRedo.add(new AddCommand(way));
-                        } else {
-                                Way copy = new Way(way);
-                                int i;
-                                for (i = 0; i < way.segments.size(); ++i)
-                                        if (way.segments.get(i).from == s.to)
-                                                break;
-                                copy.segments.add(i, s);
-                                Main.main.undoRedo.add(new ChangeCommand(way, copy));
-                        }
-                }
-                Main.ds.setSelected(way);
-        }
-
-        /**
-         * Form a way, either out of the (one) selected way or by creating a way over the selected
-         * line segments.
-         */
-        private Way makeWay() {
-                Collection<OsmPrimitive> selection = Main.ds.getSelected();
-                if (selection.isEmpty())
-                        return null;
-
-                if (selection.size() == 1 && selection.iterator().next() instanceof Way) {
-                        Way way = (Way)selection.iterator().next();
-                        for (Segment seg : way.segments) {
-                                if (seg.incomplete) {
-                                        JOptionPane.showMessageDialog(Main.parent, tr("Warning: This way is incomplete. Try to download it before adding segments."));
-                                        break;
-                                }
-                        }
-                        return way;
-                }
-
-                HashSet<Segment> segmentSet = new HashSet<Segment>();
-                int numberOfSelectedWays = 0;
-                for (OsmPrimitive osm : selection) {
-                        if (osm instanceof Way)
-                                numberOfSelectedWays++;
-                        else if (osm instanceof Segment)
-                                segmentSet.add((Segment)osm);
-                }
-
-                Way wayToAdd = null;
-                boolean reordered = false;
-                if (numberOfSelectedWays > 0) {
-                        int answer = JOptionPane.showConfirmDialog(Main.parent,trn("{0} way has been selected.\nDo you wish to select all segments belonging to the way instead?","{0} ways have been selected.\nDo you wish to select all segments belonging to the ways instead?",numberOfSelectedWays,numberOfSelectedWays),tr("Add segments from ways"), JOptionPane.YES_NO_OPTION);
-                        if (answer == JOptionPane.YES_OPTION) {
-                                for (OsmPrimitive osm : selection)
-                                        if (osm instanceof Way)
-                                                segmentSet.addAll(((Way)osm).segments);
-                        } else if (numberOfSelectedWays == 1) {
-                                answer = JOptionPane.showConfirmDialog(Main.parent,tr("Do you want to add all other selected segments to the one selected way?"),tr("Add segments to way?"), JOptionPane.YES_NO_OPTION);
-                                if (answer == JOptionPane.YES_OPTION) {
-                                        for (OsmPrimitive osm : selection) {
-                                                if (osm instanceof Way) {
-                                                        wayToAdd = (Way)osm;
-                                                        answer = JOptionPane.showConfirmDialog(Main.parent,tr("Reorder all line segments?"), tr("Reorder?"), JOptionPane.YES_NO_CANCEL_OPTION);
-                                                        if (answer == JOptionPane.CANCEL_OPTION)
-                                                                return wayToAdd;
-                                                        if (answer == JOptionPane.YES_OPTION) {
-                                                                segmentSet.addAll(wayToAdd.segments);
-                                                                reordered = true;
-                                                        } else
-                                                                segmentSet.removeAll(wayToAdd.segments);
-                                                        break;
-                                                }
-                                        }
-                                }
-                        }
-                }
-
-                if (segmentSet.isEmpty())
-                        return null;
-
-                LinkedList<Segment> rawSegments = new LinkedList<Segment>(segmentSet);
-                LinkedList<Segment> sortedSegments = ReorderAction.sortSegments(rawSegments, true);
-
-                if (wayToAdd != null) {
-                        Way w = new Way(wayToAdd);
-                        if (reordered)
-                                w.segments.clear();
-                        w.segments.addAll(sortedSegments);
-                        Main.main.undoRedo.add(new ChangeCommand(wayToAdd, w));
-                        return wayToAdd;
-                }
-
-                if (JOptionPane.YES_OPTION != JOptionPane.showConfirmDialog(Main.parent,trn("Create a new way out of {0} segment?","Create a new way out of {0} segments?",sortedSegments.size(),sortedSegments.size()), tr("Create new way"), JOptionPane.YES_NO_OPTION))
-                        return null;
-
-                Way w = new Way();
-                w.segments.addAll(sortedSegments);
-                Main.main.undoRedo.add(new AddCommand(w));
-                return w;
-        }
-
-        public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
-                if (newSelection.size() == 1) {
-                        OsmPrimitive osm = newSelection.iterator().next();
-                        way = osm instanceof Way ? (Way)osm : null;
-                } else
-                        way = null;
-    }
-}

branch/0.5/src/org/openstreetmap/josm/actions/mapmode/DeleteAction.java

@@ -24 +24 @@
 import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
-import org.openstreetmap.josm.data.osm.Segment;
 import org.openstreetmap.josm.data.osm.Way;
 import org.openstreetmap.josm.data.osm.visitor.CollectBackReferencesVisitor;
@@ -38 +37 @@
  * @see #deleteWithReferences(OsmPrimitive)
  *
- * Pressing Alt will select the way instead of a segment, as usual.
- * 
  * If the user did not press Ctrl and the object has any references, the user
  * is informed and nothing is deleted.
@@ -57 +54 @@
                 super(tr("Delete"), 
                                 "delete", 
-                                tr("Delete nodes, streets or segments."), 
+                                tr("Delete nodes or ways."), 
                                 KeyEvent.VK_D, 
                                 mapFrame, 
@@ -92 +89 @@
                         return;
                 
-                OsmPrimitive sel = Main.map.mapView.getNearest(e.getPoint(), (e.getModifiersEx() & MouseEvent.ALT_DOWN_MASK) != 0);
+                OsmPrimitive sel = Main.map.mapView.getNearest(e.getPoint());
                 if (sel == null)
                         return;
@@ -105 +102 @@
 
         /**
-         * Delete the primitives and everything they references.
+         * Delete the primitives and everything they reference.
          * 
-         * If a node is deleted, the node and all segments, ways and areas
+         * If a node is deleted, the node and all ways and relations
          * the node is part of are deleted as well.
          * 
-         * If a segment is deleted, all ways the segment is part of 
-         * are deleted as well. No nodes are deleted.
+         * If a way is deleted, all relations the way is member of are also deleted.
          * 
-         * If a way is deleted, only the way and no segments or nodes are 
-         * deleted.
-         * 
-         * If an area is deleted, only the area gets deleted.
+         * If a way is deleted, only the way and no nodes are deleted.
          * 
          * @param selection The list of all object to be deleted.
@@ -134 +127 @@
          * inform the user and do not delete.
          * 
-         * If deleting a node which is part of exactly two segments, and both segments
-         * have no conflicting keys, join them and remove the node.
-         * If the two segments are part of the same way, remove the deleted segment
-         * from the way.
+         * If a node is to be deleted which is in the middle of exactly one way,
+         * the node is removed from the way's node list and after that removed
+         * itself.
          * 
          * @param selection The objects to delete.
@@ -149 +141 @@
                         if (!selection.containsAll(v.data)) {
                                 if (osm instanceof Node && joinIfPossible) {
-                                        String reason = deleteNodeAndJoinSegment((Node)osm);
+                                        String reason = deleteNodeAndJoinWay((Node)osm);
                                         if (reason != null && msgBox) {
                                                 JOptionPane.showMessageDialog(Main.parent,tr("Cannot delete node.")+" "+reason);
@@ -167 +159 @@
         }
 
-        private String deleteNodeAndJoinSegment(Node n) {
-                ArrayList<Segment> segs = new ArrayList<Segment>(2);
-                for (Segment s : Main.ds.segments) {
-                        if (!s.deleted && (s.from == n || s.to == n)) {
-                                if (segs.size() > 1)
-                                        return tr("Used by more than two segments.");
-                                segs.add(s);
-                        }
-                }
-                if (segs.size() != 2)
-                        return tr("Used by only one segment.");
-                Segment seg1 = segs.get(0);
-                Segment seg2 = segs.get(1);
-                if (seg1.from == seg2.to) {
-                        Segment s = seg1;
-                        seg1 = seg2;
-                        seg2 = s;
-                }
-                if (seg1.from == seg2.from || seg1.to == seg2.to)
-                        return tr("Wrong direction of segments.");
-                for (Entry<String, String> e : seg1.entrySet())
-                        if (seg2.keySet().contains(e.getKey()) && !seg2.get(e.getKey()).equals(e.getValue()))
-                                return tr("Conflicting keys");
-                ArrayList<Way> ways = new ArrayList<Way>(2);
+        private String deleteNodeAndJoinWay(Node n) {
+                ArrayList<Way> ways = new ArrayList<Way>(1);
                 for (Way w : Main.ds.ways) {
-                        if (w.deleted)
-                                continue;
-                        if ((w.segments.contains(seg1) && !w.segments.contains(seg2)) || (w.segments.contains(seg2) && !w.segments.contains(seg1)))
-                                return tr("Segments are part of different ways.");
-                        if (w.segments.contains(seg1) && w.segments.contains(seg2))
+                        if (!w.deleted && w.nodes.contains(n)) {
                                 ways.add(w);
                 }
-                Segment s = new Segment(seg1);
-                s.to = seg2.to;
-                if (s.keys == null)
-                        s.keys = seg2.keys;
-                else if (seg2.keys != null)
-                        s.keys.putAll(seg2.keys);
-                Collection<Command> cmds = new LinkedList<Command>();
-                for (Way w : ways) {
-                        Way copy = new Way(w);
-                        copy.segments.remove(seg2);
-                        cmds.add(new ChangeCommand(w, copy));
                 }
-                cmds.add(new ChangeCommand(seg1, s));
-                cmds.add(new DeleteCommand(Arrays.asList(new OsmPrimitive[]{n, seg2})));
-                Main.main.undoRedo.add(new SequenceCommand(tr("Delete Node"), cmds));
+
+                if (ways.size() > 1)
+                        return tr("Used by more than one way.");
+                
+                if (ways.size() == 1) {
+                        // node in way
+                        Way w = ways.get(0);
+
+                        int i = w.nodes.indexOf(n);
+                        if (w.nodes.lastIndexOf(n) != i)
+                                return tr("Occurs more than once in the same way.");
+                        if (i == 0 || i == w.nodes.size() - 1)
+                                return tr("Is at the end of a way");
+
+                        Way wnew = new Way(w);
+                        wnew.nodes.remove(i);
+
+                        Collection<Command> cmds = new LinkedList<Command>();
+                        cmds.add(new ChangeCommand(w, wnew));
+                        cmds.add(new DeleteCommand(Collections.singleton(n)));
+                        Main.main.undoRedo.add(new SequenceCommand(tr("Delete Node"), cmds));
+                } else {
+                        // unwayed node
+                        Main.main.undoRedo.add(new DeleteCommand(Collections.singleton(n)));    
+                }
                 return null;
     }

branch/0.5/src/org/openstreetmap/josm/actions/mapmode/MapMode.java

@@ -15 +15 @@
 /**
  * A class implementing MapMode is able to be selected as an mode for map editing.
- * As example scrolling the map is a MapMode, connecting Nodes to new Segments
+ * As example scrolling the map is a MapMode, connecting Nodes to new Ways
  * is another.
  * 

branch/0.5/src/org/openstreetmap/josm/actions/mapmode/MoveAction.java

@@ -162 +162 @@
 
                 Collection<OsmPrimitive> sel = Main.ds.getSelected();
-                OsmPrimitive osm = Main.map.mapView.getNearest(e.getPoint(), (e.getModifiersEx() & MouseEvent.ALT_DOWN_MASK) != 0);
+                OsmPrimitive osm = Main.map.mapView.getNearest(e.getPoint());
                 if (osm != null) {
                         if (!sel.contains(osm))

branch/0.5/src/org/openstreetmap/josm/actions/mapmode/SelectionAction.java

@@ -17 +17 @@
 import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
-import org.openstreetmap.josm.data.osm.Segment;
 import org.openstreetmap.josm.gui.MapFrame;
 import org.openstreetmap.josm.gui.SelectionManager;
@@ -55 +54 @@
  * pixel are considered "only click". If that happens, the nearest Node will
  * be selected if there is any within 10 pixel range. If there is no Node within
- * 10 pixel, the nearest Segment (or Street, if user hold down the Alt-Key)
- * within 10 pixel range is selected. If there is no Segment within 10 pixel
- * and the user clicked in or 10 pixel away from an area, this area is selected.
- * If there is even no area, nothing is selected. Shift and Ctrl key applies to
- * this as usual. For more, @see MapView#getNearest(Point, boolean)
+ * 10 pixel, the nearest Way within 10 pixel range is selected. If there is no
+ * Way within 10 pixel and the user clicked in or 10 pixel away from an area,
+ * this area is selected.  If there is even no area, nothing is selected.
+ * Shift and Ctrl key applies to this as usual. For more,
+ * @see MapView#getNearest(Point)
  *
  * @author imi
@@ -65 +64 @@
 public class SelectionAction extends MapMode implements SelectionEnded {
 
-        enum Mode {select, straight}
-        private final Mode mode;
-
         public static class Group extends GroupAction {
                 public Group(MapFrame mf) {
                         super(KeyEvent.VK_S,0);
                         putValue("help", "Action/Selection");
-                        actions.add(new SelectionAction(mf, tr("Selection"), Mode.select, tr("Select objects by dragging or clicking.")));
-                        actions.add(new SelectionAction(mf, tr("Straight line"), Mode.straight, tr("Select objects in a straight line.")));
+                        actions.add(new SelectionAction(mf, tr("Selection"), tr("Select objects by dragging or clicking.")));
                         setCurrent(0);
                 }
@@ -84 +79 @@
         private SelectionManager selectionManager;
 
-        private Node straightStart = null;
-        private Node lastEnd = null;
-        private Collection<OsmPrimitive> oldSelection = null;
-
-        //TODO: Implement reverse references into data objects and remove this
-        private final Map<Node, Collection<Segment>> reverseSegmentMap = new HashMap<Node, Collection<Segment>>();
-
         /**
          * Create a new SelectionAction in the given frame.
          * @param mapFrame The frame this action belongs to
          */
-        public SelectionAction(MapFrame mapFrame, String name, Mode mode, String desc) {
-                super(name, "selection/"+mode, desc, mapFrame, ImageProvider.getCursor("normal", "selection"));
-                this.mode = mode;
-                putValue("help", "Action/Selection/"+Character.toUpperCase(mode.toString().charAt(0))+mode.toString().substring(1));
+        public SelectionAction(MapFrame mapFrame, String name, String desc) {
+                super(name, "selection/select", desc, mapFrame, ImageProvider.getCursor("normal", "selection"));
+                putValue("help", "Action/Selection");
                 this.selectionManager = new SelectionManager(this, false, mapFrame.mapView);
         }
@@ -104 +91 @@
         @Override public void enterMode() {
                 super.enterMode();
-                if (mode == Mode.select)
                         selectionManager.register(Main.map.mapView);
-                else {
-                        Main.map.mapView.addMouseMotionListener(this);
-                        Main.map.mapView.addMouseListener(this);
-                        for (Segment s : Main.ds.segments) {
-                                addBackReference(s.from, s);
-                                addBackReference(s.to, s);
-                        }
-                }
-        }
-
-        private void addBackReference(Node n, Segment s) {
-                Collection<Segment> c = reverseSegmentMap.get(n);
-                if (c == null) {
-                        c = new HashSet<Segment>();
-                        reverseSegmentMap.put(n, c);
-                }
-                c.add(s);
         }
 
         @Override public void exitMode() {
                 super.exitMode();
-                if (mode == Mode.select)
                         selectionManager.unregister(Main.map.mapView);
-                else {
-                        Main.map.mapView.removeMouseMotionListener(this);
-                        Main.map.mapView.removeMouseListener(this);
-                        reverseSegmentMap.clear();
-                }
         }
 
@@ -163 +126 @@
                 Main.map.mapView.repaint();
     }
-
-        @Override public void mouseDragged(MouseEvent e) {
-                Node old = lastEnd;
-                lastEnd = Main.map.mapView.getNearestNode(e.getPoint());
-                if (straightStart == null)
-                        straightStart = lastEnd;
-                if (straightStart != null && lastEnd != null && straightStart != lastEnd && old != lastEnd) {
-                        Collection<OsmPrimitive> path = new HashSet<OsmPrimitive>();
-                        Collection<OsmPrimitive> sel = new HashSet<OsmPrimitive>();
-                        path.add(straightStart);
-                        calculateShortestPath(path, straightStart, lastEnd);
-                        if ((e.getModifiers() & MouseEvent.CTRL_MASK) != 0) {
-                                sel.addAll(oldSelection);
-                                sel.removeAll(path);
-                        } else if ((e.getModifiers() & MouseEvent.SHIFT_MASK) != 0) {
-                                sel = path;
-                                sel.addAll(oldSelection);
-                        } else
-                                sel = path;
-                        Main.ds.setSelected(sel);
-                }
-        }
-
-        @Override public void mousePressed(MouseEvent e) {
-                straightStart = Main.map.mapView.getNearestNode(e.getPoint());
-                lastEnd = null;
-                oldSelection = Main.ds.getSelected();
-        }
-
-        @Override public void mouseReleased(MouseEvent e) {
-                straightStart = null;
-                lastEnd = null;
-                oldSelection = null;
-        }
-
-        /**
-         * Get the shortest path by stepping through the node with a common segment with start
-         * and nearest to the end (greedy algorithm).
-         */
-        private void calculateShortestPath(Collection<OsmPrimitive> path, Node start, Node end) {
-                for (Node pivot = start; pivot != null;)
-                        pivot = addNearest(path, pivot, end);
-        }
-
-        private Node addNearest(Collection<OsmPrimitive> path, Node start, Node end) {
-                Collection<Segment> c = reverseSegmentMap.get(start);
-                if (c == null)
-                        return null; // start may be a waypoint without segments
-                double min = Double.MAX_VALUE;
-                Node next = null;
-                Segment seg = null;
-                for (Segment s : c) {
-                        Node other = s.from == start ? s.to : s.from;
-                        if (other == end) {
-                                next = other;
-                                seg = s;
-                                min = 0;
-                                break;
-                        }
-                        double distance = other.eastNorth.distance(end.eastNorth);
-                        if (distance < min) {
-                                min = distance;
-                                next = other;
-                                seg = s;
-                        }
-                }
-                if (min < start.eastNorth.distance(end.eastNorth) && next != null) {
-                        path.add(next);
-                        path.add(seg);
-                        return next;
-                }
-                return null;
-        }
 }