Changeset 4464 – JOSM

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/actions/CombineWayAction.java

-              r4437
+              r4464
 import java.util.HashMap;
 import java.util.LinkedList;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.ArrayList;
 import java.util.Map;
 import java.util.Set;
 …
 import java.util.TreeSet;
 import java.util.Map.Entry;
+import java.util.HashSet;
 import javax.swing.Box;
 …
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.NodePair;
 import org.openstreetmap.josm.tools.GBC;
 …
         public CombineWayAction() {
                 super(tr("Combine Way"), "combineway", tr("Combine several ways into one."), KeyEvent.VK_C, KeyEvent.CTRL_MASK | KeyEvent.SHIFT_MASK, true);
                 DataSet.listeners.add(this);
+                DataSet.selListeners.add(this);
+        }
 …
+                }
+                Way oldWay = selectedWays.poll();
+                Way newWay = new Way(oldWay);
+                LinkedList<Command> cmds = new LinkedList<Command>();
+                // Battle plan:
+                //  1. Split the ways into small chunks of 2 nodes and weed out
+                //         duplicates.
+                //  2. Take a chunk and see if others could be appended or prepended,
+                //         if so, do it and remove it from the list of remaining chunks.
+                //         Rather, rinse, repeat.
+                //  3. If this algorithm does not produce a single way,
+                //     complain to the user.
+                //  4. Profit!
+                for (Way w : selectedWays)
+                        newWay.segments.addAll(w.segments);
+                HashSet<NodePair> chunkSet = new HashSet<NodePair>();
+                for (Way w : selectedWays) {
+                        if (w.nodes.size() == 0) continue;
+                        Node lastN = null;
+                        for (Node n : w.nodes) {
+                                if (lastN == null) {
+                                        lastN = n;
+                                        continue;
+                                }
+                                chunkSet.add(new NodePair(lastN, n));
+                                lastN = n;
+                        }
+                }
+                LinkedList<NodePair> chunks = new LinkedList<NodePair>(chunkSet);
+                if (chunks.isEmpty()) {
+                        JOptionPane.showMessageDialog(Main.parent, tr("All the ways were empty"));
+                        return;
+                }
+                List<Node> nodeList = chunks.poll().toArrayList();
+                while (!chunks.isEmpty()) {
+                        ListIterator<NodePair> it = chunks.listIterator();
+                        boolean foundChunk = false;
+                        while (it.hasNext()) {
+                                NodePair curChunk = it.next();
+                                if (curChunk.a == nodeList.get(nodeList.size() - 1)) { // append
+                                        nodeList.add(curChunk.b);
+                                        foundChunk = true;
+                                } else if (curChunk.b == nodeList.get(0)) { // prepend
+                                        nodeList.add(0, curChunk.a);
+                                        foundChunk = true;
+                                }
+                                if (foundChunk) {
+                                        it.remove();
+                                        break;
+                                }
+                        }
+                        if (!foundChunk) break;
+                }
+                if (!chunks.isEmpty()) {
+                        JOptionPane.showMessageDialog(Main.parent,
+                                tr("Could not combine ways (Hint: ways have to point into the same direction)"));
+                        return;
+                }
+                Way newWay = new Way(selectedWays.get(0));
+                newWay.nodes.clear();
+                newWay.nodes.addAll(nodeList);
                 // display conflict dialog
 …
+                }
+                cmds.add(new DeleteCommand(selectedWays));
+                cmds.add(new ChangeCommand(oldWay, newWay));
+                LinkedList<Command> cmds = new LinkedList<Command>();
+                cmds.add(new DeleteCommand(selectedWays.subList(1, selectedWays.size())));
+                cmds.add(new ChangeCommand(selectedWays.peek(), newWay));
                 Main.main.undoRedo.add(new SequenceCommand(tr("Combine {0} ways", selectedWays.size()), cmds));
                 Main.ds.setSelected(oldWay);
+                Main.ds.setSelected(selectedWays.peek());
+        }

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/actions/SplitWayAction.java

-              r4437
+              r4464
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Set;
 import java.util.Map.Entry;
 …
 import org.openstreetmap.josm.data.SelectionChangedListener;
 import org.openstreetmap.josm.data.osm.DataSet;
+import org.openstreetmap.josm.data.osm.Relation;
 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.NameVisitor;
 …
 /**
+ * Splits a way into multiple ways (all identical except the segments
+ * belonging to the way).
+ * Splits a way into multiple ways (all identical except for their node list).
+ *
+ * Various split modes are used depending on what is selected.
+ *
+ * 1. One or more NODES (and, optionally, also one way) selected:
+ *
+ * (All nodes must be part of the same way. If a way is also selected, that way
+ * must contain all selected nodes.)
+ *
+ * Way is split AT the node(s) into contiguous ways. If the original contained
+ * one or more parts that were not reachable from any of the nodes, they form an
+ * extra new way. Examples (numbers are unselected nodes, letters are selected
+ * nodes)
+ *
+ * 1---A---2  becomes  1---A and A---2
+ *
+ * 1---A---2---B---3  becomes  1---A and A---2---B and B---3
+ *
+ *     2
+ *     |
+ * 1---A---3  becomes  1---A and 2---A and A---3
+ *
+ * 1---A---2  3---4  becomes  1---A and A---2 and 3---4
+ *
+ * If the selected node(s) do not clearly define the way that is to be split,
+ * then the way must be selected for disambiguation (e.g. you have two ways,
+ * 1---2---3 and 4---2---5, and select node 2, then you must also select the
+ * way you want to split).
+ *
+ * This function will result in at least two ways, unless the selected node is
+ * at the end of the way AND the way is contiguous, which will lead to an error
+ * message.
+ *
+ * After executing the operation, the selection will be cleared.
+ *
+ * 2. One or more SEGMENTS (and, optionally, also one way) selected:
+ *
+ * (All segments must be part of the same way)
+ *
+ * The way is split in a fashion that makes a new way from the selected segments,
+ * i.e. the selected segments are removed from the way to form a new one.
+ *
+ * This function will result in exactly two ways.
+ *
+ * If splitting the segments out of the way makes a non-contiguous part from
+ * something that was contiguous before, the action is aborted and an error
+ * message is shown.
+ *
+ * 3. Exactly one WAY selected
+ *
+ * If the way is contiguous, you will get an error message. If the way is not
+ * contiguous it is split it into 2...n contiguous ways.
+ * Ways are just split at the selected nodes.  The nodes remain in their
+ * original order.  Selected nodes at the end of a way are ignored.
  */
 …
         private Way selectedWay;
         private List<Node> selectedNodes;
-        private List<Segment> selectedSegments;
         /**
 …
         public SplitWayAction() {
                 super(tr("Split Way"), "splitway", tr("Split a way at the selected node."), KeyEvent.VK_P, KeyEvent.CTRL_MASK | KeyEvent.SHIFT_MASK, true);
                 DataSet.listeners.add(this);
+                DataSet.selListeners.add(this);
+        }
 …
                 selectedWay = null;
                 selectedNodes = null;
-                selectedSegments = null;
                 Visitor splitVisitor = new Visitor(){
 …
                                 selectedNodes.add(n);
+            }
-                        public void visit(Segment s) {
-                                if (selectedSegments == null)
-                                        selectedSegments = new LinkedList<Segment>();
-                                selectedSegments.add(s);
+            }
                         public void visit(Way w) {
                                 selectedWay = w;
+            }
+                        public void visit(Relation e) {
+                                // enties are not considered
+                        }
                 };
 …
                         for (Node n : selectedNodes) {
                                 for (Way w : Main.ds.ways) {
                                         for (Segment s : w.segments) {
                                                 if (n.equals(s.from) || n.equals(s.to)) {
+                                        for (Node wn : w.nodes) {
+                                                if (n.equals(wn)) {
                                                         Integer old = wayOccurenceCounter.get(w);
                                                         wayOccurenceCounter.put(w, (old == null) ? 1 : old+1);
 …
                         HashSet<Node> nds = new HashSet<Node>(selectedNodes);
+                        for (Segment s : selectedWay.segments) {
+                                nds.remove(s.from);
+                                nds.remove(s.to);
+                        for (Node n : selectedWay.nodes) {
+                                nds.remove(n);
+                        }
                         if (!nds.isEmpty()) {
 …
                                 return;
+                        }
-                        // If only segments are selected, guess which way to use.
-                } else if (selectedWay == null && selectedSegments != null) {
-                        HashMap<Way, Integer> wayOccurenceCounter = new HashMap<Way, Integer>();
-                        for (Segment s : selectedSegments) {
-                                for (Way w : Main.ds.ways) {
-                                        if (w.segments.contains(s)) {
-                                                Integer old = wayOccurenceCounter.get(w);
-                                                wayOccurenceCounter.put(w, (old == null) ? 1 : old+1);
-                                                break;
+                                        }
+                                }
+                        }
-                        if (wayOccurenceCounter.isEmpty()) {
-                                JOptionPane.showMessageDialog(Main.parent,
-                                                trn("The selected segment is not part of any way.",
-                                                                "The selected segments are not part of any way.", selectedSegments.size()));
-                                return;
+                        }
-                        for (Entry<Way, Integer> entry : wayOccurenceCounter.entrySet()) {
-                                if (entry.getValue().equals(selectedSegments.size())) {
-                                        if (selectedWay != null) {
-                                                JOptionPane.showMessageDialog(Main.parent,
-                                                                trn("There is more than one way using the segment you selected. Please select the way also.",
-                                                                                "There is more than one way using the segments you selected. Please select the way also.", selectedSegments.size()));
-                                                return;
+                                        }
-                                        selectedWay = entry.getKey();
+                                }
+                        }
-                        if (selectedWay == null) {
-                                JOptionPane.showMessageDialog(Main.parent, tr("The selected segments do not share the same way."));
-                                return;
+                        }
-                        // If a way and segments are selected, verify that the segments are part of the way.
-                } else if (selectedWay != null && selectedSegments != null) {
-                        if (!selectedWay.segments.containsAll(selectedSegments)) {
-                                JOptionPane.showMessageDialog(Main.parent,
-                                                trn("The selected way does not contain the selected segment.",
-                                                                "The selected way does not contain all the selected segments.", selectedSegments.size()));
-                                return;
+                        }
+                }
-                // finally check if the selected way is complete.
-                if (selectedWay.isIncomplete()) {
-                        JOptionPane.showMessageDialog(Main.parent, tr("Warning: This way is incomplete. Try to download it before splitting."));
-                        return;
+                }
 …
         private boolean checkSelection(Collection<? extends OsmPrimitive> selection) {
                 boolean way = false;
-                boolean segment = false;
                 boolean node = false;
                 for (OsmPrimitive p : selection) {
                         if (p instanceof Way && !way)
+                        if (p instanceof Way && !way) {
                                 way = true;
                         else if (p instanceof Node && !segment)
+                        } else if (p instanceof Node) {
                                 node = true;
+                        else if (p instanceof Segment && !node)
+                                segment = true;
+                        else
+                        } else {
                                 return false;
+                }
+                return way || segment || node;
+                }
+                return node;
+        }
 …
          * Split a way into two or more parts, starting at a selected node.
+         *
+         * FIXME: what do the following "arguments" refer to?
          * @param way the way to split
          * @param nodes the node(s) to split the way at; must be part of the way.
          */
         private void splitWay() {
+                // The basic idea is to first divide all segments forming this way into
+                // groups, and later form new ways according to the groups. Initally,
+                // all segments are copied into allSegments, and then gradually removed
+                // from there as new groups are built.
+                LinkedList<Segment> allSegments = new LinkedList<Segment>();
+                allSegments.addAll(selectedWay.segments);
+                List<List<Segment>> segmentSets = new ArrayList<List<Segment>>();
+                if (selectedNodes != null) {
+                        // This is the "split at node" mode.
+                        boolean split = true;
+                        Segment splitSeg = null;
+                        while (split) {
+                                split = false;
+                                // Look for a "split segment". A split segment is any segment
+                                // that touches one of the split nodes and has not yet been
+                                // assigned to one of the segment groups.
+                                for (Segment s : allSegments) {
+                                        for (Node node : selectedNodes) {
+                                                if (s.from.equals(node) || s.to.equals(node)) {
+                                                        split = true;
+                                                        splitSeg = s;
+                                                        break;
+                                                }
+                                        }
+                                        if (split)
+                                                break;
+                // We take our way's list of nodes and copy them to a way chunk (a
+                // list of nodes).  Whenever we stumble upon a selected node, we start
+                // a new way chunk.
+                Set<Node> nodeSet = new HashSet<Node>(selectedNodes);
+                List<List<Node>> wayChunks = new LinkedList<List<Node>>();
+                List<Node> currentWayChunk = new ArrayList<Node>();
+                wayChunks.add(currentWayChunk);
+                Iterator<Node> it = selectedWay.nodes.iterator();
+                while (it.hasNext()) {
+                        Node currentNode = it.next();
+                        boolean atEndOfWay = currentWayChunk.isEmpty() || !it.hasNext();
+                        currentWayChunk.add(currentNode);
+                        if (nodeSet.contains(currentNode) && !atEndOfWay) {
+                                currentWayChunk = new ArrayList<Node>();
+                                currentWayChunk.add(currentNode);
+                                wayChunks.add(currentWayChunk);
+                                }
+                                // If a split segment was found, move this segment and all segments
+                                // connected to it into a new segment group, stopping only if we
+                                // reach another split node. Segment moving is done recursively by
+                                // the moveSegments method.
+                                if (split) {
+                                        LinkedList<Segment> subSegments = new LinkedList<Segment>();
+                                        moveSegments(allSegments, subSegments, splitSeg, selectedNodes);
+                                        segmentSets.add(subSegments);
+                                }
+                                // The loop continues until no more split segments were found.
+                                // Nb. not all segments touching a split node are split segments;
+                                // e.g.
+                                //
+                                //     2       4
+                                //     |       |
+                                // 1---A---3---C---5
+                                //
+                                // This way will be split into 5 ways (1---A,2---A,A---3---C,4---C,
+                                // C---5). Depending on which is processed first, either A---3 becomes
+                                // a split segment and 3---C is moved as a connecting segment, or vice
+                                // versa. The result is, of course, the same but this explains why we
+                                // cannot simply start a new way for each segment connecting to a split
+                                // node.
+                        }
+                } else if (selectedSegments != null) {
+                        // This is the "split segments" mode. It is quite easy as the segments to
+                        // remove are already explicitly selected, but some restrictions have to
+                        // be observed to make sure that no non-contiguous parts are created.
+                        // first create a "scratch" copy of the full segment list and move all
+                        // segments connected to the first selected segment into a temporary list.
+                        LinkedList<Segment> copyOfAllSegments = new LinkedList<Segment>(allSegments);
+                        LinkedList<Segment> partThatContainsSegments = new LinkedList<Segment>();
+                        moveSegments(copyOfAllSegments, partThatContainsSegments, selectedSegments.get(0), null);
+                        // this list must now contain ALL selected segments; otherwise, segments
+                        // from unconnected parts of the way have been selected and this is not allowed
+                        // as it would create a new non-contiguous way.
+                        if (!partThatContainsSegments.containsAll(selectedSegments)) {
+                                JOptionPane.showMessageDialog(Main.parent, tr("The selected segments are not in the same contiguous part of the way."));
+                                return;
+                        }
+                        // if the contiguous part that contains the segments becomes non-contiguous
+                        // after the removal of the segments, that is also an error.
+                        partThatContainsSegments.removeAll(selectedSegments);
+                        if (!partThatContainsSegments.isEmpty()) {
+                                LinkedList<Segment> contiguousSubpart = new LinkedList<Segment>();
+                                moveSegments(partThatContainsSegments, contiguousSubpart, partThatContainsSegments.get(0), null);
+                                // if partThatContainsSegments was contiguous before, it will now be empty as all segments
+                                // connected to the first segment therein have been moved
+                                if (!partThatContainsSegments.isEmpty()) {
+                                        JOptionPane.showMessageDialog(Main.parent, tr("Removing the selected segments would make a part of the way non-contiguous."));
+                                        return;
+                                }
+                        }
+                        ArrayList<Segment> subSegments = new ArrayList<Segment>();
+                        subSegments.addAll(selectedSegments);
+                        allSegments.removeAll(selectedSegments);
+                        segmentSets.add(subSegments);
+                } else {
+                        // This is the "split way into contiguous parts" mode.
+                        // We use a similar mechanism to splitting at nodes, but we do not
+                        // select split segments. Instead, we randomly grab a segment out
+                        // of the way and move all connecting segments to a new group. If
+                        // segments remain in the original way, we repeat the procedure.
+                        while (!allSegments.isEmpty()) {
+                                LinkedList<Segment> subSegments = new LinkedList<Segment>();
+                                moveSegments(allSegments, subSegments, allSegments.get(0), null);
+                                segmentSets.add(subSegments);
+                        }
+                }
+                // We now have a number of segment groups.
+                // If segments remain in allSegments, this means that they were not reachable
+                // from any of the split nodes, and they will be made into an extra way.
+                if (!allSegments.isEmpty()) {
+                        segmentSets.add(allSegments);
+                }
+                // If we do not have at least two parts, then the way was circular or the node(s)
+                // were at one end of the way. User error ;-)
+                if (segmentSets.size() < 2) {
+                        if (selectedNodes != null) {
+                                JOptionPane.showMessageDialog(Main.parent, tr("The way cannot be split at the selected node. (Hint: To split circular ways, select two nodes.)"));
+                        } else {
+                                JOptionPane.showMessageDialog(Main.parent, tr("The way cannot be split because it is contiguous. (Hint: To split at a node, select that node.)"));
+                        }
+                        }
+                if (wayChunks.size() < 2) {
+                        JOptionPane.showMessageDialog(Main.parent, tr("The way cannot be split at the selected nodes. (Hint: Select nodes in the middle of the way.)"));
                         return;
+                }
+                // sort the list of segment lists according to their number of elements, so that
+                // the biggest part of the way comes first. That way, we will "change" the largest
+                // part of the way by removing a few segments, and "add" new, smaller ways; looks
+                // nicer.
+                Collections.sort(segmentSets, new Comparator<Collection<Segment>>() {
+                        public int compare(Collection<Segment> a, Collection<Segment> b) {
+                                if (a.size() < b.size())
+                                        return 1;
+                                if (b.size() < a.size())
+                                        return -1;
+                                return 0;
+                        }
+                });
+                // build a list of commands, and also a list of ways
+                Collection<Command> commandList = new ArrayList<Command>(segmentSets.size());
+                Collection<Way> newSelection = new ArrayList<Way>(segmentSets.size());
+                Iterator<List<Segment>> segsIt = segmentSets.iterator();
+                // build a list of commands, and also a new selection list
+                Collection<Command> commandList = new ArrayList<Command>(wayChunks.size());
+                Collection<Way> newSelection = new ArrayList<Way>(wayChunks.size());
+                // the first is always a change to the existing way;
+                Iterator<List<Node>> chunkIt = wayChunks.iterator();
+                // First, change the original way
                 Way changedWay = new Way(selectedWay);
                 changedWay.segments.clear();
                 changedWay.segments.addAll(segsIt.next());
+                changedWay.nodes.clear();
+                changedWay.nodes.addAll(chunkIt.next());
                 commandList.add(new ChangeCommand(selectedWay, changedWay));
                 newSelection.add(selectedWay);
                 // and commands 1...n are additions of new ways.
                 while (segsIt.hasNext()) {
+                // Second, create new ways
+                while (chunkIt.hasNext()) {
                         Way wayToAdd = new Way();
                         if (selectedWay.keys != null)
                                 wayToAdd.keys = new HashMap<String, String>(selectedWay.keys);
+                        wayToAdd.segments.clear();
+                        wayToAdd.segments.addAll(segsIt.next());
+                        wayToAdd.nodes.addAll(chunkIt.next());
                         commandList.add(new AddCommand(wayToAdd));
                         newSelection.add(wayToAdd);
 …
                 NameVisitor v = new NameVisitor();
                 v.visit(selectedWay);
+                Main.main.undoRedo.add(new SequenceCommand(tr("Split way {0} into {1} parts",v.name, segmentSets.size()), commandList));
+                Main.main.undoRedo.add(
+                        new SequenceCommand(tr("Split way {0} into {1} parts",
+                                v.name, wayChunks.size()),
+                        commandList));
                 Main.ds.setSelected(newSelection);
+        }
 …
                 setEnabled(checkSelection(newSelection));
+        }
-        /**
-         * Move contiguous segments from one collection to another. The given segment is moved first, and
-         * then the procedure is recursively called for all segments that connect to the first segment at
-         * either end.
+         *
-         * @param source the source collection
-         * @param destination the destination collection
-         * @param start the first segment to be moved
-         * @param stopNodes collection of nodes which should be considered end points for moving (may be null).
-         */
-        private void moveSegments(Collection<Segment> source, LinkedList<Segment> destination, Segment start, Collection<Node> stopNodes) {
-                source.remove(start);
-                if (destination.isEmpty() || destination.iterator().next().from.equals(start.to))
-                        destination.addFirst(start);
-                else
-                        destination.addLast(start);
-                Segment moveSeg = start;
-                while(moveSeg != null) {
-                        moveSeg = null;
-                        for (Node node : new Node[] { start.from, start.to }) {
-                                if (stopNodes != null && stopNodes.contains(node))
-                                        continue;
-                                for (Segment sourceSeg : source) {
-                                        if (sourceSeg.from.equals(node) || sourceSeg.to.equals(node)) {
-                                                moveSeg = sourceSeg;
-                                                break;
+                                        }
+                                }
-                                if (moveSeg != null)
-                                        break;
+                        }
-                        if (moveSeg != null) {
-                                moveSegments(source, destination, moveSeg, stopNodes);
+                        }
+                }
+        }
+}

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/actions/mapmode/AddNodeAction.java

-              r4437
+              r4464
 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;
 …
  * 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.
 …
 public class AddNodeAction extends MapMode {
         enum Mode {node, nodesegment, autonode}
+        enum Mode {node, nodeway, autonode}
         private final Mode mode;
 …
                         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);
+                }
 …
          * 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) {
 …
                 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);
 …
                         // 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);
+                }
 …
                 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;
 …
                         // 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;
 …
                         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
 …
+                                }
+                                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);
+                        }
+                }
 …
         /**
          * @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.
          */
 …
                 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;
+        }
+}

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/actions/mapmode/AddSegmentAction.java

-              r4437
+              r4464
 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;
 …
          */
         public AddSegmentAction(MapFrame mapFrame) {
                 super(tr("Add segment"),
+                super(tr("Connect two node"),
                                 "addsegment",
                                 tr("Add a segment between two nodes."),
+                                tr("Connect two nodes using ways."),
                                 KeyEvent.VK_G,
                                 mapFrame,
 …
                         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;
+        }
 …
                         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 == null || hovered == first) return;
+                drawHint(false);
+                second = (Node)clicked;
+                second = hovered;
                 drawHint(true);
+        }
 …
         @Override public void mouseReleased(MouseEvent e) {
                 if (e.getButton() == MouseEvent.BUTTON1) {
+                        drawHint(false);
                         makeSegment();
-                        first = null; // release segment drawing
+                }
+        }
+        /**
+         * @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;
+        }
 …
          */
         private void makeSegment() {
+                if (first == null || second == null) {
+                Node n1 = first;
+                Node n2 = second;
                         first = null;
                         second = null;
+                        return;
+                if (n1 == null || n2 == null || n1 == n2) return;
+                Way w = getWayForNode(n1);
+                Way wnew;
+                if (w == null) {
+                        wnew = new Way();
+                        wnew.nodes.add(n1);
+                        wnew.nodes.add(n2);
+                        Main.main.undoRedo.add(new AddCommand(wnew));
+                } else {
+                        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));
+                }
-                drawHint(false);
-                Node start = first;
-                Node end = second;
-                first = second;
-                second = null;
-                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);
+                sel.add(wnew);
                         Main.ds.setSelected(sel);
+                }
                 Main.map.mapView.repaint();

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/actions/mapmode/DeleteAction.java

-              r4437
+              r4464
 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;
 …
  * @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.
 …
                 super(tr("Delete"),
                                 "delete",
                                 tr("Delete nodes, streets or segments."),
+                                tr("Delete nodes or ways."),
                                 KeyEvent.VK_D,
                                 mapFrame,
 …
                         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;
 …
         /**
          * 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.
 …
          * 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.
 …
                         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);
 …
+        }
+        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);
+                }
+                if (ways.size() > 1)
+                        return tr("Used by more than one 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>();
+                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})));
+                cmds.add(new ChangeCommand(w, wnew));
+                cmds.add(new DeleteCommand(Collections.singleton(n)));
                 Main.main.undoRedo.add(new SequenceCommand(tr("Delete Node"), cmds));
                 return null;

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/actions/mapmode/MapMode.java

r4437	r4464
15	15	/**
16	16	* A class implementing MapMode is able to be selected as an mode for map editing.
17		* As example scrolling the map is a MapMode, connecting Nodes to new ~~Segment~~s
	17	* As example scrolling the map is a MapMode, connecting Nodes to new Ways
18	18	* is another.
19	19	*

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/actions/mapmode/MoveAction.java

r4437	r4464
162	162
163	163	Collection<OsmPrimitive> sel = Main.ds.getSelected();
164		OsmPrimitive osm = Main.map.mapView.getNearest(e.getPoint()~~, (e.getModifiersEx() & MouseEvent.ALT_DOWN_MASK) != 0~~);
	164	OsmPrimitive osm = Main.map.mapView.getNearest(e.getPoint());
165	165	if (osm != null) {
166	166	if (!sel.contains(osm))

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/actions/mapmode/SelectionAction.java

-              r4437
+              r4464
 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;
 …
  * 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
 …
 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);
+                }
 …
         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);
+        }
 …
         @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();
+                }
+        }
 …
                 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;
+        }
+}

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/actions/search/SearchCompiler.java

-              r4437
+              r4464
 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;
 …
                         if (osm instanceof Node)
                                 return type.equals("node");
-                        if (osm instanceof Segment)
-                                return type.equals("segment");
                         if (osm instanceof Way)
                                 return type.equals("way");
 …
         private static class Incomplete extends Match {
                 @Override public boolean match(OsmPrimitive osm) {
                         return osm instanceof Way && ((Way)osm).isIncomplete();
+                        return false;
+                }
                 @Override public String toString() {return "incomplete";}

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/command/AddCommand.java

-              r4437
+              r4464
 import org.openstreetmap.josm.Main;
 import org.openstreetmap.josm.data.osm.DataSet;
+import org.openstreetmap.josm.data.osm.Relation;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.osm.visitor.AddVisitor;
 …
  * A command that adds an osm primitive to a dataset. Keys cannot be added this
  * way. Use ChangeKeyValueCommand instead.
+ *
+ * See ChangeCommand for comments on relation back references.
+ *
  * @author imi

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/command/ChangeCommand.java

-              r4437
+              r4464
 import org.openstreetmap.josm.data.osm.visitor.NameVisitor;
+/**
+ * Command that basically replaces one OSM primitive by another of the
+ * same type.
+ *
+ * @author Imi
+ */
 public class ChangeCommand extends Command {

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/command/Command.java

-              r4437
+              r4464
 import javax.swing.tree.MutableTreeNode;
+import org.openstreetmap.josm.data.osm.Relation;
 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.Visitor;
 …
                         orig.put(n, new Node(n));
+                }
-                public void visit(Segment s) {
-                        orig.put(s, new Segment(s));
+                }
                 public void visit(Way w) {
                         orig.put(w, new Way(w));
+                }
+                public void visit(Relation e) {
+                        orig.put(e, new Relation(e));
+                }
+        }

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/command/DeleteCommand.java

-              r4437
+              r4464
 import javax.swing.tree.MutableTreeNode;
+import org.openstreetmap.josm.data.osm.Relation;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.osm.visitor.NameVisitor;
 …
         @Override public void executeCommand() {
                 super.executeCommand();
                 for (OsmPrimitive osm : data)
+                for (OsmPrimitive osm : data) {
                         osm.delete(true);
+                }
+        }
         @Override public void fillModifiedData(Collection<OsmPrimitive> modified, Collection<OsmPrimitive> deleted, Collection<OsmPrimitive> added) {
                 deleted.addAll(data);

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/data/Preferences.java

-              r4437
+              r4464
         /**
+         * Override some values on read. This is intended to be used for technology previews
+         * where we want to temporarily modify things without changing the user's preferences
+         * file.
+         */
+        protected static final SortedMap<String, String> override = new TreeMap<String, String>();
+        static {
+                override.put("osm-server.version", "0.5");
+                override.put("osm-server.additional-versions", "");
+                override.put("osm-server.url", "http://openstreetmap.gryph.de/api");
+                override.put("osm-server.username", "fred@remote.org");
+                override.put("osm-server.password", "fredfred");
+                override.put("plugins", null);
+        }
+        /**
          * Return the location of the user defined preferences file
          */
 …
         /**
          * @return A list of all existing directories, where ressources could be stored.
+         * @return A list of all existing directories, where resources could be stored.
          */
         public Collection<String> getAllPossiblePreferenceDirs() {
 …
         synchronized public boolean hasKey(final String key) {
                 return properties.containsKey(key);
+                return override.containsKey(key) ? override.get(key) != null : properties.containsKey(key);
+        }
         synchronized public String get(final String key) {
+                if (override.containsKey(key))
+                        return override.get(key);
                 if (!properties.containsKey(key))
                         return "";
 …
+        }
         synchronized public String get(final String key, final String def) {
+                if (override.containsKey(key))
+                        return override.get(key);
                 final String prop = properties.get(key);
                 if (prop == null || prop.equals(""))
 …
                         if (e.getKey().startsWith(prefix))
                                 all.put(e.getKey(), e.getValue());
+                for (final Entry<String,String> e : override.entrySet())
+                        if (e.getKey().startsWith(prefix))
+                                if (e.getValue() == null)
+                                        all.remove(e.getKey());
+                                else
+                                        all.put(e.getKey(), e.getValue());
                 return all;
+        }
 …
+        }
         synchronized public boolean getBoolean(final String key, final boolean def) {
+                if (override.containsKey(key))
+                        return override.get(key) == null ? def : Boolean.parseBoolean(override.get(key));
                 return properties.containsKey(key) ? Boolean.parseBoolean(properties.get(key)) : def;
+        }
 …
                 try {
                         final PrintWriter out = new PrintWriter(new FileWriter(getPreferencesDir() + "preferences"), false);
                         for (final Entry<String, String> e : properties.entrySet())
+                        for (final Entry<String, String> e : properties.entrySet()) {
                                 if (!e.getValue().equals(""))
                                         out.println(e.getKey() + "=" + e.getValue());
+                        }
                         out.close();
                 } catch (final IOException e) {

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/data/ServerSidePreferences.java

r4437	r4464
45	45	public String download() {
46	46	try {
47		System.out.println("reading preferenced from "+serverUrl);
	47	System.out.println("reading preferences from "+serverUrl);
48	48	HttpURLConnection con = (HttpURLConnection)serverUrl.openConnection();
49	49	addAuth(con);

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/data/osm/DataSet.java

-              r4437
+              r4464
         /**
+         * All segments goes here, even when they are in a way.
+         * All ways (Streets etc.) in the DataSet.
+         *
+         * The way nodes are stored only in the way list.
          */
         public Collection<Segment> segments = new LinkedList<Segment>();
+        public Collection<Way> ways = new LinkedList<Way>();
         /**
+         * All ways (Streets etc.) in the DataSet.
+         *
+         * The nodes of the way segments of this way must be objects from
+         * the nodes list, however the way segments are stored only in the
+         * way list.
+         * All relations/relationships
          */
         public Collection<Way> ways = new LinkedList<Way>();
+        public Collection<Relation> relations = new LinkedList<Relation>();
         /**
 …
          * selection does only change in the active layer)
          */
         public static Collection<SelectionChangedListener> listeners = new LinkedList<SelectionChangedListener>();
+        public static Collection<SelectionChangedListener> selListeners = new LinkedList<SelectionChangedListener>();
         /**
          * @return A collection containing all primitives of the dataset. The
          * data is ordered after: first comes nodes, then segments, then ways.
+         * data is ordered after: first come nodes, then ways, then relations.
          * Ordering in between the categories is not guaranteed.
          */
 …
                 List<OsmPrimitive> o = new LinkedList<OsmPrimitive>();
                 o.addAll(nodes);
-                o.addAll(segments);
                 o.addAll(ways);
+                o.addAll(relations);
                 return o;
+        }
 …
         public void clearSelection() {
                 clearSelection(nodes);
-                clearSelection(segments);
                 clearSelection(ways);
+                clearSelection(relations);
                 Collection<OsmPrimitive> sel = Collections.emptyList();
                 fireSelectionChanged(sel);
 …
         public Collection<OsmPrimitive> getSelected() {
                 Collection<OsmPrimitive> sel = getSelected(nodes);
-                sel.addAll(getSelected(segments));
                 sel.addAll(getSelected(ways));
+                sel.addAll(getSelected(relations));
                 return sel;
+        }
 …
         public void setSelected(Collection<? extends OsmPrimitive> selection) {
                 clearSelection(nodes);
-                clearSelection(segments);
                 clearSelection(ways);
+                clearSelection(relations);
                 for (OsmPrimitive osm : selection)
                         osm.selected = true;
 …
+                }
                 clearSelection(nodes);
-                clearSelection(segments);
                 clearSelection(ways);
+                clearSelection(relations);
                 for (OsmPrimitive o : osm)
                         if (o != null)
 …
          */
         public static void fireSelectionChanged(Collection<? extends OsmPrimitive> sel) {
                 for (SelectionChangedListener l : listeners)
+                for (SelectionChangedListener l : selListeners)
                         l.selectionChanged(sel);
+        }
         @Override public DataSet clone() {
                 DataSet ds = new DataSet();
                 for (Node n : nodes)
                         ds.nodes.add(new Node(n));
-                for (Segment s : segments)
-                        ds.segments.add(new Segment(s));
                 for (Way w : ways)
                         ds.ways.add(new Way(w));
+                for (Relation e : relations)
+                        ds.relations.add(new Relation(e));
                 for (DataSource source : dataSources)
                         ds.dataSources.add(new DataSource(source.bounds, source.origin));

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/data/osm/Node.java

-              r4437
+              r4464
         public volatile EastNorth eastNorth;
+        /**
+         * Create an incomplete Node object
+         */
+        public Node(long id) {
+                this.id = id;
+                incomplete = true;
+        }
         /**
          * Create an identical clone of the argument (including the id)

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/data/osm/OsmPrimitive.java

-              r4437
+              r4464
 import java.text.SimpleDateFormat;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 …
         /**
+         * If set to true, this object is incomplete, which means only the id
+         * and type is known (type is the objects instance class)
+         */
+        public boolean incomplete = false;
+        /**
          * Implementation of the visitor scheme. Subclases have to call the correct
          * visitor function.
 …
                 Visitor v = new Visitor(){
                         public void visit(Node n) { ret[0] = 1; }
                         public void visit(Segment s) { ret[0] = 2; }
                         public void visit(Way w) { ret[0] = 3; }
+                        public void visit(Way w) { ret[0] = 2; }
+                        public void visit(Relation e) { ret[0] = 3; }
                 };
                 visit(v);
                 return id == 0 ? super.hashCode() : (int)(id<<3)+ret[0];
+                return id == 0 ? super.hashCode() : (int)(id<<2)+ret[0];
+        }
 …
                 return timestamp == null ? null : new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(timestamp);
+        }
+}

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/data/osm/Way.java

-              r4437
+              r4464
 /**
  * One full way, consisting of several way segments chained together.
+ * One full way, consisting of a list of way nodes.
+ *
  * @author imi
 …
         /**
          * All way segments in this way
+         * All way nodes in this way
          */
         public final List<Segment> segments = new ArrayList<Segment>();
+        public final List<Node> nodes = new ArrayList<Node>();
         @Override public void visit(Visitor visitor) {
 …
+        }
+        /**
+         * Create an empty way without id. Use this only if you set meaningful
+         * values yourself.
+         */
         public Way() {
+        }
+        /**
+         * Create an incomplete Way.
+         */
+        public Way(long id) {
+                this.id = id;
+                incomplete = true;
+        }
         @Override public void cloneFrom(OsmPrimitive osm) {
                 super.cloneFrom(osm);
                 segments.clear();
                 segments.addAll(((Way)osm).segments);
+                nodes.clear();
+                nodes.addAll(((Way)osm).nodes);
+        }
     @Override public String toString() {
         return "{Way id="+id+" segments="+Arrays.toString(segments.toArray())+"}";
+        return "{Way id="+id+" nodes="+Arrays.toString(nodes.toArray())+"}";
+    }
         @Override public boolean realEqual(OsmPrimitive osm, boolean semanticOnly) {
                 return osm instanceof Way ? super.realEqual(osm, semanticOnly) && segments.equals(((Way)osm).segments) : false;
+                return osm instanceof Way ? super.realEqual(osm, semanticOnly) && nodes.equals(((Way)osm).nodes) : false;
+    }
 …
+    }
+        @Deprecated
         public boolean isIncomplete() {
-                for (Segment s : segments)
-                        if (s.incomplete)
-                                return true;
                 return false;
+        }

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/data/osm/visitor/AddVisitor.java

-              r4437
+              r4464
 // License: GPL. Copyright 2007 by Immanuel Scholz and others
-/**
- */
 package org.openstreetmap.josm.data.osm.visitor;
 import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.data.osm.Segment;
+import org.openstreetmap.josm.data.osm.Relation;
 import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.Way;
 …
                 ds.nodes.add(n);
+        }
-        public void visit(Segment s) {
-                ds.segments.add(s);
+        }
         public void visit(Way w) {
                 ds.ways.add(w);
+        }
+        public void visit(Relation e) {
+                ds.relations.add(e);
+        }
+}

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/data/osm/visitor/AllNodesVisitor.java

-              r4437
+              r4464
 import java.util.HashSet;
+import org.openstreetmap.josm.data.osm.Segment;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.RelationMember;
 import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 …
         /**
          * Line segments have exactly two nodes: from and to.
+         * Ways have their way nodes.
          */
+        public void visit(Segment ls) {
+                if (!ls.incomplete) {
+                        visit(ls.from);
+                        visit(ls.to);
+                }
+        public void visit(Way w) {
+                for (Node n : w.nodes)
+                        visit(n);
+        }
         /**
+         * Ways have all nodes from their segments.
+         * Relations may have any number of nodes.
+         * FIXME: do we want to collect nodes from segs/ways that are relation members?
+         * if so, use AutomatchVisitor!
          */
         public void visit(Way w) {
                 for (Segment ls : w.segments)
                         visit(ls);
+        public void visit(Relation e) {
+                for (RelationMember m : e.members)
+                        if (m.member instanceof Node) visit((Node)m.member);
+        }
         /**
          * @return All nodes the given primitive has.

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/data/osm/visitor/BoundingXYVisitor.java

-              r4437
+              r4464
 import org.openstreetmap.josm.data.Bounds;
 import org.openstreetmap.josm.data.coor.EastNorth;
 import org.openstreetmap.josm.data.osm.Segment;
+import org.openstreetmap.josm.data.osm.Relation;
 import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.Way;
 …
+        }
+        public void visit(Segment ls) {
+                if (!ls.incomplete) {
+                        visit(ls.from);
+                        visit(ls.to);
+                }
+        public void visit(Way w) {
+                for (Node n : w.nodes)
+                        visit(n);
+        }
+        public void visit(Way w) {
+                for (Segment ls : w.segments)
+                        visit(ls);
+        public void visit(Relation e) {
+                // relations have no bounding box.
+        }

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/data/osm/visitor/CollectBackReferencesVisitor.java

-              r4437
+              r4464
 import org.openstreetmap.josm.data.osm.DataSet;
+import org.openstreetmap.josm.data.osm.Segment;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.RelationMember;
 import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 …
 /**
+ * Helper that collect all segments a node is part of, all ways
+ * a node or segment is part of and all areas a node is part of.
+ * Helper that collect all ways a node is part of.
+ *
  * Deleted objects are not collected.
 …
                         if (w.deleted)
                                 continue;
+                        for (Segment ls : w.segments) {
+                                if (ls.incomplete)
+                                        continue;
+                                if (ls.from == n || ls.to == n) {
+                        for (Node n2 : w.nodes) {
+                                if (n == n2) {
                                         data.add(w);
+                                }
+                        }
+                }
+                checkRelationMembership(n);
+        }
+        public void visit(Way w) {
+                checkRelationMembership(w);
+        }
+        public void visit(Relation r) {
+                checkRelationMembership(r);
+        }
+        private void checkRelationMembership(OsmPrimitive p) {
+                // FIXME - this might be a candidate for optimisation
+                // if OSM primitives are made to hold a list of back
+                // references.
+                for (Relation r : ds.relations) {
+                        for (RelationMember m : r.members) {
+                                if (m.member == p) {
+                                        data.add(r);
+                                        // move up the tree (there might be relations
+                                        // referring to this relation)
+                                        checkRelationMembership(r);
                                         break;
+                                }
+                        }
+                }
-                for (Segment ls : ds.segments) {
-                        if (ls.deleted || ls.incomplete)
-                                continue;
-                        if (ls.from == n || ls.to == n)
-                                data.add(ls);
+                }
+        }
-        public void visit(Segment ls) {
-                for (Way w : ds.ways) {
-                        if (w.deleted)
-                                continue;
-                        if (w.segments.contains(ls))
-                                data.add(w);
+                }
+        }
-        public void visit(Way w) {}
+}

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/data/osm/visitor/DeleteVisitor.java

-              r4437
+              r4464
 // License: GPL. Copyright 2007 by Immanuel Scholz and others
-/**
- */
 package org.openstreetmap.josm.data.osm.visitor;
 import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.data.osm.Segment;
+import org.openstreetmap.josm.data.osm.Relation;
 import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.Way;
 …
                 ds.nodes.remove(n);
+        }
-        public void visit(Segment ls) {
-                ds.segments.remove(ls);
+        }
         public void visit(Way w) {
                 ds.ways.remove(w);
+        }
+        public void visit(Relation e) {
+                ds.relations.remove(e);
+        }
+}

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/data/osm/visitor/MergeVisitor.java

-              r4437
+              r4464
 import org.openstreetmap.josm.data.osm.DataSet;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.RelationMember;
 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;
 …
         /**
          * Map from primitives in the database to visited primitives. (Attention: The other way
          * round than mergedNodes and mergedSegments)
+         * round than mergedNodes)
          */
         public Map<OsmPrimitive, OsmPrimitive> conflicts = new HashMap<OsmPrimitive, OsmPrimitive>();
 …
          */
         private final Map<Node, Node> mergedNodes = new HashMap<Node, Node>();
-        /**
-         * A list of all segments that got replaced with others.
-         * Key is the segment in the other's dataset and the value is the one that is now
-         * in ds.segments.
-         */
-        private final Map<Segment, Segment> mergedSegments = new HashMap<Segment, Segment>();
         public MergeVisitor(DataSet ds, DataSet mergeds) {
 …
         /**
+         * Merge the segment if id matches or if both nodes are the same (and the
+         * id is zero of either segment). Nodes are the "same" when they @see match
+         */
+        public void visit(Segment other) {
+                if (mergeAfterId(mergedSegments, ds.segments, other))
+                        return;
+                Segment my = null;
+                for (Segment ls : ds.segments) {
+                        if (match(other, ls) && ((mergeds == null) || (!mergeds.segments.contains(ls)))) {
+                                my = ls;
+                                break;
+                        }
+                }
+                if (my == null)
+                        ds.segments.add(other);
+                else if (my.incomplete && !other.incomplete) {
+                        mergedSegments.put(other, my);
+                        my.cloneFrom(other);
+                } else if (!other.incomplete) {
+                        mergedSegments.put(other, my);
+                        mergeCommon(my, other);
+                        if (my.modified && !other.modified)
+                                return;
+                        if (!match(my.from, other.from)) {
+                                my.from = other.from;
+                                my.modified = other.modified;
+                        }
+                        if (!match(my.to, other.to)) {
+                                my.to = other.to;
+                                my.modified = other.modified;
+                        }
+                }
+        }
+         * Simply calls cloneFrom() for now.
+         * Might be useful to keep around to facilitate merge with the relations
+         * branch.
+         */
         private <T extends OsmPrimitive> void cloneFromExceptIncomplete(T myOsm, T otherOsm) {
+                if (!(myOsm instanceof Way))
+                        myOsm.cloneFrom(otherOsm);
+                else {
+                        Way my = (Way)myOsm;
+                        Way other = (Way)otherOsm;
+                        HashMap<Long, Segment> copy = new HashMap<Long, Segment>();
+                        for (Segment s : my.segments)
+                                copy.put(s.id, s);
+                        my.cloneFrom(other);
+                        my.segments.clear();
+                        for (Segment s : other.segments) {
+                                Segment myS = copy.get(s.id);
+                                if (s.incomplete && myS != null && !myS.incomplete) {
+                                        mergedSegments.put(s, myS);
+                                        my.segments.add(myS);
+                                } else
+                                        my.segments.add(s);
+                        }
+                }
+                myOsm.cloneFrom(otherOsm);
+    }
         /**
          * Merge the way if id matches or if all segments matches and the
+         * Merge the way if id matches or if all nodes match and the
          * id is zero of either way.
          */
 …
+                }
                 if (my == null) {
-                        // Add the way and replace any incomplete segments that we already have
                         ds.ways.add(other);
+                        for (Segment s : other.segments) {
+                                if (s.incomplete) {
+                } else {
+                        mergeCommon(my, other);
+                        if (my.modified && !other.modified)
+                                return;
+                        boolean same = true;
+                        Iterator<Node> it = other.nodes.iterator();
+                        for (Node n : my.nodes) {
+                                if (!match(n, it.next()))
+                                        same = false;
+                        }
+                        if (!same) {
+                                my.nodes.clear();
+                                my.nodes.addAll(other.nodes);
+                                my.modified = other.modified;
+                        }
+                }
+        }
+        /**
+         * Merge the relation if id matches or if all members match and the
+         * id of either relation is zero.
+         */
+        public void visit(Relation other) {
+                if (mergeAfterId(null, ds.relations, other))
+                        return;
+                Relation my = null;
+                for (Relation e : ds.relations) {
+                        if (match(other, e) && ((mergeds == null) || (!mergeds.relations.contains(e)))) {
+                                my = e;
+                                break;
+                        }
+                }
+                if (my == null) {
+                        // Add the relation and replace any incomplete segments that we already have
+                        ds.relations.add(other);
+                        // FIXME unclear!
+                        /*
+                        for (RelationMember em : other.getMembers()) {
+                                if (em.member.incomplete) {
                                         for (Segment ourSegment : ds.segments) {
                                                 if (ourSegment.id == s.id) {
 …
+                                        }
+                                }
+                        }
+                        }*/
                 } else {
                         mergeCommon(my, other);
 …
                                 return;
                         boolean same = true;
+                        Iterator<Segment> it = other.segments.iterator();
+                        for (Segment ls : my.segments) {
+                                if (!match(ls, it.next()))
+                        if (other.members.size() != my.members.size()) {
                                         same = false;
+                        }
+                        } else {
+                                for (RelationMember em : my.members) {
+                                        if (!other.members.contains(em)) {
+                                                same = false;
+                                                break;
+                                        }
+                                }
+                        }
+                        // FIXME Unclear
+                        /*
                         if (!same) {
                                 HashMap<Long, Segment> copy = new HashMap<Long, Segment>();
 …
                                 my.modified = other.modified;
+                        }
+                        */
+                }
+        }
 …
          */
         public void fixReferences() {
-                for (Segment s : ds.segments)
-                        fixSegment(s);
-                for (OsmPrimitive osm : conflicts.values())
-                        if (osm instanceof Segment)
-                                fixSegment((Segment)osm);
                 for (Way w : ds.ways)
                         fixWay(w);
 …
         private void fixWay(Way w) {
             boolean replacedSomething = false;
             LinkedList<Segment> newSegments = new LinkedList<Segment>();
             for (Segment ls : w.segments) {
                 Segment otherLs = mergedSegments.get(ls);
                 newSegments.add(otherLs == null ? ls : otherLs);
                 if (otherLs != null)
+            LinkedList<Node> newNodes = new LinkedList<Node>();
+            for (Node n : w.nodes) {
+                Node otherN = mergedNodes.get(n);
+                newNodes.add(otherN == null ? n : otherN);
+                if (otherN != null)
                         replacedSomething = true;
+            }
             if (replacedSomething) {
+                w.segments.clear();
+                w.segments.addAll(newSegments);
+            }
+            for (Segment ls : w.segments)
+                fixSegment(ls);
+                w.nodes.clear();
+                w.nodes.addAll(newNodes);
+    }
-        private void fixSegment(Segment ls) {
-            if (mergedNodes.containsKey(ls.from))
-                ls.from = mergedNodes.get(ls.from);
-            if (mergedNodes.containsKey(ls.to))
-                ls.to = mergedNodes.get(ls.to);
+    }
         /**
          * @return Whether the nodes matches (in sense of "be mergable").
+         * @return Whether the nodes match (in sense of "be mergable").
          */
         private boolean match(Node n1, Node n2) {
 …
         /**
+         * @return Whether the segments matches (in sense of "be mergable").
+         */
+        private boolean match(Segment ls1, Segment ls2) {
+                if (ls1.id == ls2.id && ls1.id != 0)
+                        return true;
+                //if (ls1.id != 0 && ls2.id != 0)
+                //      return false;
+                if (ls1.incomplete || ls2.incomplete)
+                        return false;
+                return match(ls1.from, ls2.from) && match(ls1.to, ls2.to);
+        }
+        /**
+         * @return Whether the ways matches (in sense of "be mergable").
+         * @return Whether the ways match (in sense of "be mergable").
          */
         private boolean match(Way w1, Way w2) {
                 if (w1.id == 0 || w2.id == 0) {
                         if (w1.segments.size() != w2.segments.size())
                                 return false;
                         Iterator<Segment> it = w1.segments.iterator();
                         for (Segment ls : w2.segments)
                                 if (!match(ls, it.next()))
+                        if (w1.nodes.size() != w2.nodes.size())
+                        return false;
+                        Iterator<Node> it = w1.nodes.iterator();
+                        for (Node n : w2.nodes)
+                                if (!match(n, it.next()))
                                         return false;
                         return true;
 …
                 return w1.id == w2.id;
+        }
+        /**
+         * @return Whether the relations match (in sense of "be mergable").
+         */
+        private boolean match(Relation w1, Relation w2) {
+                // FIXME this is not perfect yet...
+                if (w1.id == 0 || w2.id == 0) {
+                        if (w1.members.size() != w2.members.size())
+                                return false;
+                        for (RelationMember em : w1.members) {
+                                if (!w2.members.contains(em)) {
+                                        return false;
+                                }
+                        }
+                        return true;
+                }
+                return w1.id == w2.id;
+        }
         /**
 …
+                        }
                         if (my.id == other.id && my.id != 0) {
-                                if (my instanceof Segment && ((Segment)my).incomplete)
-                                        return false; // merge always over an incomplete
                                 if (my.modified && other.modified) {
                                         conflicts.put(my, other);

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/data/osm/visitor/NameVisitor.java

-              r4437
+              r4464
 // License: GPL. Copyright 2007 by Immanuel Scholz and others
 package org.openstreetmap.josm.data.osm.visitor;
 …
 import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.data.osm.Relation;
 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.tools.ImageProvider;
 …
         /**
-         * If the segment has a key named "name", its value is displayed.
-         * Otherwise, if it has "id", this is used. If none of these available,
-         * "(x1,y1) -> (x2,y2)" is displayed with the nodes coordinates.
-         */
-        public void visit(Segment ls) {
-                name = ls.get("name");
-                if (name == null) {
-                        if (ls.incomplete)
-                                name = ls.id == 0 ? tr("new") : ls.id+" ("+tr("unknown")+")";
-                        else
-                                name = (ls.id==0?"":ls.id+" ")+"("+ls.from.coor.lat()+","+ls.from.coor.lon()+") -> ("+ls.to.coor.lat()+","+ls.to.coor.lon()+")";
+                }
-                addId(ls);
-                icon = ImageProvider.get("data", "segment");
-                trn("segment", "segments", 0); // no marktrn available
-                className = "segment";
+        }
-        /**
          * If the node has a name-key or id-key, this is displayed. If not, (lat,lon)
          * is displayed.
 …
                 if (name == null) name = w.get("ref");
                 if (name == null) {
-                        AllNodesVisitor.getAllNodes(w.segments);
-                        Set<Node> nodes = new HashSet<Node>();
-                        for (Segment ls : w.segments) {
-                                if (!ls.incomplete) {
-                                        nodes.add(ls.from);
-                                        nodes.add(ls.to);
+                                }
+                        }
                         String what = (w.get("highway") != null) ? "highway " : (w.get("railway") != null) ? "railway " : (w.get("waterway") != null) ? "waterway " : "";
                         name = what + trn("{0} node", "{0} nodes", nodes.size(), nodes.size());
+                        name = what + trn("{0} node", "{0} nodes", w.nodes.size(), w.nodes.size());
+                }
-                if (w.isIncomplete())
-                        name += " ("+tr("incomplete")+")";
                 addId(w);
                 icon = ImageProvider.get("data", "way");
                 trn("way", "ways", 0); // no marktrn available
                 className = "way";
+        }
+        /**
+         */
+        public void visit(Relation e) {
+                name = e.get("type");
+                // FIXME add names of members
+                if (name == null)
+                        name = "relation";
+                addId(e);
+                icon = ImageProvider.get("data", "relation");
+                trn("relation", "relations", 0); // no marktrn available
+                className = "relation";
+        }

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/data/osm/visitor/SimplePaintVisitor.java

-              r4437
+              r4464
 import java.awt.Color;
 import java.awt.Graphics;
-import java.awt.Graphics2D;
 import java.awt.Point;
-import java.awt.Polygon;
 import java.awt.Rectangle;
-import java.awt.geom.GeneralPath;
 import java.awt.geom.Line2D;
 import org.openstreetmap.josm.Main;
 import org.openstreetmap.josm.data.osm.DataSet;
+import org.openstreetmap.josm.data.osm.Relation;
 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.NavigatableComponent;
 …
         public final static Color darkblue = new Color(0,0,128);
         public final static Color darkgreen = new Color(0,128,0);
         /**
          * The environment to paint to.
 …
         public boolean inactive;
         protected static final double PHI = Math.toRadians(20);
-        /**
-         * Preferences
-         */
-        protected Color inactiveColor;
-        protected Color selectedColor;
-        protected Color nodeColor;
-        protected Color segmentColor;
-        protected Color dfltWayColor;
-        protected Color incompleteColor;
-        protected Color backgroundColor;
-        protected boolean showDirectionArrow;
-        protected boolean showOrderNumber;
-        /**
-         * Draw subsequent segments of same color as one Path
-         */
-        protected Color currentColor = null;
-        protected GeneralPath currrentPath = new GeneralPath();
         public void visitAll(DataSet data) {
-                inactiveColor = getPreferencesColor("inactive", Color.DARK_GRAY);
-                selectedColor = getPreferencesColor("selected", Color.WHITE);
-                nodeColor = getPreferencesColor("node", Color.RED);
-                segmentColor = getPreferencesColor("segment", darkgreen);
-                dfltWayColor = getPreferencesColor("way", darkblue);
-                incompleteColor = getPreferencesColor("incomplete way", darkerblue);
-                backgroundColor = getPreferencesColor("background", Color.BLACK);
-                showDirectionArrow = Main.pref.getBoolean("draw.segment.direction");
-                showOrderNumber = Main.pref.getBoolean("draw.segment.order_number");
-                for (final OsmPrimitive osm : data.segments)
-                        if (!osm.deleted && !osm.selected)
-                                osm.visit(this);
                 for (final OsmPrimitive osm : data.ways)
                         if (!osm.deleted && !osm.selected)
                                 osm.visit(this);
-                displaySegments(null);  // Flush segment cache before nodes
                 for (final OsmPrimitive osm : data.nodes)
                         if (!osm.deleted && !osm.selected)
 …
                         if (!osm.deleted)
                                 osm.visit(this);
-                displaySegments(null);
+        }
 …
                 Color color = null;
                 if (inactive)
                         color = inactiveColor;
+                        color = getPreferencesColor("inactive", Color.DARK_GRAY);
                 else if (n.selected)
                         color = selectedColor;
+                        color = getPreferencesColor("selected", Color.WHITE);
                 else
                         color = nodeColor;
+                        color = getPreferencesColor("node", Color.RED);
                 drawNode(n, color);
+        }
-        /**
-         * Draw just a line between the points.
-         * White if selected (as always) or green otherwise.
-         */
-        public void visit(Segment ls) {
-                Color color;
-                if (inactive)
-                        color = inactiveColor;
-                else if (ls.selected)
-                        color = selectedColor;
-                else
-                        color = segmentColor;
-                drawSegment(ls, color, showDirectionArrow);
+        }
 …
                 Color wayColor;
                 if (inactive)
                         wayColor = inactiveColor;
+                        wayColor = getPreferencesColor("inactive", Color.DARK_GRAY);
                 else {
+                        wayColor = dfltWayColor;
+                        for (Segment ls : w.segments) {
+                                if (ls.incomplete) {
+                                        wayColor = incompleteColor;
+                                        break;
+                                }
+                        }
+                        wayColor = getPreferencesColor("way", darkblue);
+                }
+                boolean showDirectionArrow = Main.pref.getBoolean("draw.segment.direction");
+                boolean showOrderNumber = Main.pref.getBoolean("draw.segment.order_number");
                 int orderNumber = 0;
+                for (Segment ls : w.segments) {
+                Node lastN = null;
+                for (Node n : w.nodes) {
+                        if (lastN == null) {
+                                lastN = n;
+                                continue;
+                        }
                         orderNumber++;
                         if (!ls.selected) // selected already in good color
                                 drawSegment(ls, w.selected && !inactive ? selectedColor : wayColor, showDirectionArrow);
                         if (!ls.incomplete && showOrderNumber)
                                 drawOrderNumber(ls, orderNumber);
+                        drawSegment(lastN, n, w.selected && !inactive ? getPreferencesColor("selected", Color.WHITE) : wayColor, showDirectionArrow);
+                        if (showOrderNumber)
+                                drawOrderNumber(lastN, n, orderNumber);
+                        lastN = n;
+                }
+        }
+        public void visit(Relation e) {
+                // relations are not drawn.
+        }
         /**
+         * Draw an number of the order of the segment within the parents way
+         * Draw an number of the order of the two consecutive nodes within the
+         * parents way
          */
         protected void drawOrderNumber(Segment ls, int orderNumber) {
+        protected void drawOrderNumber(Node n1, Node n2, int orderNumber) {
                 int strlen = (""+orderNumber).length();
                 Point p1 = nc.getPoint(ls.from.eastNorth);
                 Point p2 = nc.getPoint(ls.to.eastNorth);
+                Point p1 = nc.getPoint(n1.eastNorth);
+                Point p2 = nc.getPoint(n2.eastNorth);
                 int x = (p1.x+p2.x)/2 - 4*strlen;
                 int y = (p1.y+p2.y)/2 + 4;
 …
                 if (screen.contains(x,y)) {
                         Color c = g.getColor();
                         g.setColor(backgroundColor);
+                        g.setColor(getPreferencesColor("background", Color.BLACK));
                         g.fillRect(x-1, y-12, 8*strlen+1, 14);
                         g.setColor(c);
 …
          * Draw a line with the given color.
          */
+        protected void drawSegment(Segment ls, Color col, boolean showDirection) {
+                if (ls.incomplete)
+                        return;
+                if (col != currentColor) {
+                        displaySegments(col);
+                }
+        protected void drawSegment(Node n1, Node n2, Color col, boolean showDirection) {
+                g.setColor(col);
+                Point p1 = nc.getPoint(n1.eastNorth);
+                Point p2 = nc.getPoint(n2.eastNorth);
+                Point p1 = nc.getPoint(ls.from.eastNorth);
+                Point p2 = nc.getPoint(ls.to.eastNorth);
+                Rectangle screen = g.getClipBounds();
+                Rectangle screen = g.getClipBounds();
                 Line2D line = new Line2D.Double(p1.x, p1.y, p2.x, p2.y);
                 if (screen.contains(p1.x, p1.y, p2.x, p2.y) || screen.intersectsLine(line))
+                {
+                        currrentPath.moveTo(p1.x, p1.y);
+                        currrentPath.lineTo(p2.x, p2.y);
+                        g.drawLine(p1.x, p1.y, p2.x, p2.y);
                         if (showDirection) {
                                 double t = Math.atan2(p2.y-p1.y, p2.x-p1.x) + Math.PI;
+                                currrentPath.lineTo((int)(p2.x + 10*Math.cos(t-PHI)), (int)(p2.y + 10*Math.sin(t-PHI)));
+                                currrentPath.moveTo((int)(p2.x + 10*Math.cos(t+PHI)), (int)(p2.y + 10*Math.sin(t+PHI)));
+                                currrentPath.lineTo(p2.x, p2.y);                        }
+                }
+        }
+        protected void displaySegments(Color newColor) {
+                if (currrentPath != null) {
+                        g.setColor(currentColor);
+                        ((Graphics2D) g).draw(currrentPath);
+                        currrentPath = new GeneralPath();
+                        currentColor = newColor;
+                        g.drawLine(p2.x,p2.y, (int)(p2.x + 10*Math.cos(t-PHI)), (int)(p2.y + 10*Math.sin(t-PHI)));
+                        g.drawLine(p2.x,p2.y, (int)(p2.x + 10*Math.cos(t+PHI)), (int)(p2.y + 10*Math.sin(t+PHI)));
+                        }
+                }
+        }

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/data/osm/visitor/Visitor.java

-              r4437
+              r4464
 package org.openstreetmap.josm.data.osm.visitor;
+import org.openstreetmap.josm.data.osm.Relation;
 import org.openstreetmap.josm.data.osm.Node;
-import org.openstreetmap.josm.data.osm.Segment;
 import org.openstreetmap.josm.data.osm.Way;
 …
 public interface Visitor {
         void visit(Node n);
-        void visit(Segment s);
         void visit(Way w);
+        void visit(Relation e);
+}

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/gui/ConflictResolver.java

-              r4437
+              r4464
 import org.openstreetmap.josm.data.conflict.ConflictItem;
 import org.openstreetmap.josm.data.conflict.DeleteConflict;
-import org.openstreetmap.josm.data.conflict.FromConflict;
 import org.openstreetmap.josm.data.conflict.PositionConflict;
 import org.openstreetmap.josm.data.conflict.PropertyConflict;
-import org.openstreetmap.josm.data.conflict.SegmentConflict;
-import org.openstreetmap.josm.data.conflict.ToConflict;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.tools.GBC;
 …
                 possibleConflicts.add(new DeleteConflict());
                 possibleConflicts.add(new PositionConflict());
-                possibleConflicts.add(new FromConflict());
-                possibleConflicts.add(new ToConflict());
-                possibleConflicts.add(new SegmentConflict());
                 TreeSet<String> allkeys = new TreeSet<String>();
                 for (Entry<OsmPrimitive, OsmPrimitive> e : conflicts.entrySet()) {

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/gui/GettingStarted.java

-              r4437
+              r4464
                 panel = new JPanel(new GridBagLayout());
+                panel.add(new JLabel("<html><h2>You are running a technology preview with support for <i>API 0.5</i>.</h2>" +
+                                "<h3>API 0.5 supports object relationships, and segments have been removed.</h3>" +
+                                "<h3>This version is hard-coded to use the API 0.5 running on <i>openstreetmap.gryph.de</i> which has data from a recent planet file."+
+                                "<br>Please be gentle with that machine and request only moderate bounding boxes.<br>" +
+                                "<br>Username and password are also hardcoded, so your real username and password are not transmitted.<br>" +
+                "</h3>"), GBC.eol());
+                addLine("wiki", "Read the [Wiki page on API 0.5]");
                 addGettingStarted();
                 addGettingHelp();
 …
                 else if (e.getActionCommand().equals("help"))
                         Main.main.menu.help.actionPerformed(e);
+                else if (e.getActionCommand().equals("wiki"))
+                        OpenBrowser.displayUrl("http://wiki.openstreetmap.org/index.php?title=OSM_Protocol_Version_0.5");
                 else if (e.getActionCommand().equals("tutorial"))
                         OpenBrowser.displayUrl("http://josm.openstreetmap.de/wiki/TutorialVideos");

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/gui/MainMenu.java

-              r4437
+              r4464
 import org.openstreetmap.josm.actions.CombineWayAction;
 import org.openstreetmap.josm.actions.DownloadAction;
-import org.openstreetmap.josm.actions.DownloadIncompleteAction;
 import org.openstreetmap.josm.actions.ExitAction;
 import org.openstreetmap.josm.actions.GpxExportAction;
 …
 import org.openstreetmap.josm.actions.PreferencesAction;
 import org.openstreetmap.josm.actions.RedoAction;
+import org.openstreetmap.josm.actions.ReorderAction;
+import org.openstreetmap.josm.actions.ReverseSegmentAction;
+import org.openstreetmap.josm.actions.ReverseWayAction;
 import org.openstreetmap.josm.actions.SaveAction;
 import org.openstreetmap.josm.actions.SaveAsAction;
 …
         public final OpenAction open = new OpenAction();
         public final DownloadAction download = new DownloadAction();
         public final Action reverseSegment = new ReverseSegmentAction();
+        public final Action reverseWay = new ReverseWayAction();
         public final Action splitWay = new SplitWayAction();
         public final Action combineWay = new CombineWayAction();
         public final Action alignInCircle = new AlignInCircleAction();
         public final Action alignInLine = new AlignInLineAction();
-        public final Action reorder = new ReorderAction();
         public final Action upload = new UploadAction();
         public final Action save = new SaveAction(null);
 …
         public final HelpAction help = new HelpAction();
         public final Action about = new AboutAction();
-        public final DownloadIncompleteAction downloadIncomplete = new DownloadIncompleteAction();
         public final JMenu layerMenu = new JMenu(tr("Layer"));
 …
                 toolsMenu.add(alignInLine);
                 toolsMenu.addSeparator();
+                toolsMenu.add(reverseSegment);
+                toolsMenu.add(reorder);
+                toolsMenu.add(reverseWay);
                 toolsMenu.addSeparator();
                 toolsMenu.add(splitWay);
 …
                 connectionMenu.setMnemonic('C');
                 connectionMenu.add(download);
-                connectionMenu.add(downloadIncomplete);
                 connectionMenu.add(upload);
                 add(connectionMenu);

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/gui/MapFrame.java

-              r4437
+              r4464
 import org.openstreetmap.josm.Main;
 import org.openstreetmap.josm.actions.mapmode.AddSegmentAction;
-import org.openstreetmap.josm.actions.mapmode.AddWayAction;
 import org.openstreetmap.josm.actions.mapmode.DeleteAction;
 import org.openstreetmap.josm.actions.mapmode.MapMode;
 …
 import org.openstreetmap.josm.gui.dialogs.CommandStackDialog;
 import org.openstreetmap.josm.gui.dialogs.ConflictDialog;
+import org.openstreetmap.josm.gui.dialogs.RelationListDialog;
 import org.openstreetmap.josm.gui.dialogs.HistoryDialog;
 import org.openstreetmap.josm.gui.dialogs.LayerListDialog;
 …
                 toolBarActions.add(new IconToggleButton(new AddNodeGroup(this)));
                 toolBarActions.add(new IconToggleButton(new AddSegmentAction(this)));
-                toolBarActions.add(new IconToggleButton(new AddWayAction(this)));
                 toolBarActions.add(new IconToggleButton(new DeleteAction(this)));
 …
                 addToggleDialog(conflictDialog = new ConflictDialog());
                 addToggleDialog(new CommandStackDialog(this));
+                addToggleDialog(new RelationListDialog());
                 // status line below the map

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/gui/MapStatus.java

r4437	r4464
126	126	OsmPrimitive osmNearest = null;
127	127	// Set the text label in the bottom status bar
128		osmNearest = mv.getNearest(ms.mousePos~~, (ms.modifiers & MouseEvent.ALT_DOWN_MASK) != 0~~);
	128	osmNearest = mv.getNearest(ms.mousePos);
129	129	if (osmNearest != null) {
130	130	NameVisitor visitor = new NameVisitor();

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/gui/MapView.java

r4437	r4464
85	85
86	86	// listend to selection changes to redraw the map
87		DataSet.listeners.add(new SelectionChangedListener(){
	87	DataSet.selListeners.add(new SelectionChangedListener(){
88	88	public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
89	89	repaint();

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/gui/NavigatableComponent.java

-              r4437
+              r4464
 import java.awt.Point;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.HashSet;
-import java.util.List;
 import javax.swing.JComponent;
 …
 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.data.projection.Projection;
 …
         /**
+         * @return the nearest way to the screen point given.
+         */
+        public final Way getNearestWay(Point p) {
+         * @return the nearest way segment to the screen point given that is not
+         * in ignore.
+         *
+         * @param p the point for which to search the nearest segment.
+         * @param ignore a collection of segments which are not to be returned.
+         * May be null.
+         */
+        public final WaySegment getNearestWaySegment(Point p, Collection<WaySegment> ignore) {
                 Way minPrimitive = null;
+                int minI = 0;
                 double minDistanceSq = Double.MAX_VALUE;
                 for (Way w : Main.ds.ways) {
                         if (w.deleted)
                                 continue;
+                        for (Segment ls : w.segments) {
+                                if (ls.deleted || ls.incomplete)
+                        Node lastN = null;
+                        int i = -2;
+                        for (Node n : w.nodes) {
+                                i++;
+                                if (n.deleted) continue;
+                                if (lastN == null) {
+                                        lastN = n;
                                         continue;
+                                Point A = getPoint(ls.from.eastNorth);
+                                Point B = getPoint(ls.to.eastNorth);
+                                }
+                                if (ignore != null && ignore.contains(new WaySegment(w, i))) {
+                                        continue;
+                                }
+                                Point A = getPoint(lastN.eastNorth);
+                                Point B = getPoint(n.eastNorth);
                                 double c = A.distanceSq(B);
                                 double a = p.distanceSq(B);
 …
                                         minDistanceSq = perDist;
                                         minPrimitive = w;
+                                }
+                                        minI = i;
+                                }
+                                lastN = n;
+                        }
+                }
+                return minPrimitive;
+        }
+        /**
+         * @return the nearest segment to the screen point given
+         *
+         * @param p the point for which to search the nearest segment.
+         */
+        public final Segment getNearestSegment(Point p) {
+                List<Segment> e = Collections.emptyList();
+                return getNearestSegment(p, e);
+                return minPrimitive == null ? null : new WaySegment(minPrimitive, minI);
+        }
+        /**
+         * @return the nearest way segment to the screen point given.
+         */
+        public final WaySegment getNearestWaySegment(Point p) {
+                return getNearestWaySegment(p, null);
+        }
         /**
+         * @return the nearest segment to the screen point given that is not
+         * in ignoreThis.
+         *
+         * @param p the point for which to search the nearest segment.
+         * @param ignore a collection of segments which are not to be returned. Must not be null.
+         */
+        public final Segment getNearestSegment(Point p, Collection<Segment> ignore) {
+                Segment minPrimitive = null;
+                double minDistanceSq = Double.MAX_VALUE;
+                // segments
+                for (Segment ls : Main.ds.segments) {
+                        if (ls.deleted || ls.incomplete || ignore.contains(ls))
+                                continue;
+                        Point A = getPoint(ls.from.eastNorth);
+                        Point B = getPoint(ls.to.eastNorth);
+                        double c = A.distanceSq(B);
+                        double a = p.distanceSq(B);
+                        double b = p.distanceSq(A);
+                        double perDist = a-(a-b+c)*(a-b+c)/4/c; // perpendicular distance squared
+                        if (perDist < 100 && minDistanceSq > perDist && a < c+100 && b < c+100) {
+                                minDistanceSq = perDist;
+                                minPrimitive = ls;
+                        }
+                }
+                return minPrimitive;
+         * @return the nearest way to the screen point given.
+         */
+        public final Way getNearestWay(Point p) {
+                WaySegment nearestWaySeg = getNearestWaySegment(p);
+                return nearestWaySeg == null ? null : nearestWaySeg.way;
+    }
 …
          * nearest node is returned.
+         *
+         * If no node is found, search for pending segments.
+         *
+         * If no such segment is found, and a non-pending segment is
+         * within 10 pixel to p, this segment is returned, except when
+         * <code>wholeWay</code> is <code>true</code>, in which case the
+         * corresponding Way is returned.
+         *
+         * If no segment is found and the point is within an area, return that
+         * area.
+         *
+         * If no area is found, return <code>null</code>.
+         * If no node is found, search for near ways.
+         *
+         * If nothing is found, return <code>null</code>.
+         *
          * @param p                              The point on screen.
-         * @param segmentInsteadWay Whether the segment (true) or only the whole
-         *                                               way should be returned.
          * @return      The primitive, that is nearest to the point p.
          */
+        public OsmPrimitive getNearest(Point p) {
+                OsmPrimitive osm = getNearestNode(p);
+                if (osm == null)
+                        osm = getNearestWay(p);
+                return osm;
+        }
+        @Deprecated
         public OsmPrimitive getNearest(Point p, boolean segmentInsteadWay) {
+                OsmPrimitive osm = getNearestNode(p);
+                if (osm == null && !segmentInsteadWay)
+                        osm = getNearestWay(p);
+                if (osm == null)
+                        osm = getNearestSegment(p);
+                return osm;
+                return getNearest(p);
+        }
         /**
          * @return A list of all objects that are nearest to
+         * the mouse. To do this, first the nearest object is
+         * determined.
+         *
+         * If its a node, return all segments and
+         * streets the node is part of, as well as all nodes
+         * (with their segments and ways) with the same
+         * location.
+         *
+         * If its a segment, return all ways this segment
+         * belongs to as well as all segments that are between
+         * the same nodes (in both direction) with all their ways.
+         * the mouse.  Does a simple sequential scan on all the data.
+         *
          * @return A collection of all items or <code>null</code>
 …
          */
         public Collection<OsmPrimitive> getAllNearest(Point p) {
+                OsmPrimitive osm = getNearest(p, true);
+                if (osm == null)
+                        return null;
+                Collection<OsmPrimitive> c = new HashSet<OsmPrimitive>();
+                c.add(osm);
+                if (osm instanceof Node) {
+                        Node node = (Node)osm;
+                        for (Node n : Main.ds.nodes)
+                                if (!n.deleted && n.coor.equals(node.coor))
+                                        c.add(n);
+                        for (Segment ls : Main.ds.segments)
+                                // segments never match nodes, so they are skipped by contains
+                                if (!ls.deleted && !ls.incomplete && (c.contains(ls.from) || c.contains(ls.to)))
+                                        c.add(ls);
+                }
+                if (osm instanceof Segment) {
+                        Segment line = (Segment)osm;
+                        for (Segment ls : Main.ds.segments)
+                                if (!ls.deleted && ls.equalPlace(line))
+                                        c.add(ls);
+                }
+                if (osm instanceof Node || osm instanceof Segment) {
+                Collection<OsmPrimitive> nearest = new HashSet<OsmPrimitive>();
                         for (Way w : Main.ds.ways) {
+                                if (w.deleted)
+                        if (w.deleted) continue;
+                        Node lastN = null;
+                        for (Node n : w.nodes) {
+                                if (n.deleted) continue;
+                                if (lastN == null) {
+                                        lastN = n;
                                         continue;
+                                for (Segment ls : w.segments) {
+                                        if (!ls.deleted && !ls.incomplete && c.contains(ls)) {
+                                                c.add(w);
+                                }
+                                Point A = getPoint(lastN.eastNorth);
+                                Point B = getPoint(n.eastNorth);
+                                double c = A.distanceSq(B);
+                                double a = p.distanceSq(B);
+                                double b = p.distanceSq(A);
+                                double perDist = a-(a-b+c)*(a-b+c)/4/c; // perpendicular distance squared
+                                if (perDist < 100 && a < c+100 && b < c+100) {
+                                        nearest.add(w);
                                                 break;
+                                        }
+                                }
+                                lastN = n;
+                                }
+                        }
+                for (Node n : Main.ds.nodes) {
+                        if (!n.deleted && getPoint(n.eastNorth).distanceSq(p) < 100) {
+                                nearest.add(n);
+                        }
+                }
                 return c;
+                return nearest.isEmpty() ? null : nearest;
+        }

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/gui/OsmPrimitivRenderer.java

-              r4437
+              r4464
 import javax.swing.DefaultListCellRenderer;
+import javax.swing.JLabel;
 import javax.swing.JList;
+import javax.swing.JTable;
+import javax.swing.ListCellRenderer;
+import javax.swing.table.DefaultTableCellRenderer;
+import javax.swing.table.TableCellRenderer;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 …
 /**
  * Renderer that renders the objects from an OsmPrimitive as data.
+ *
+ * Can be used in lists and tables.
+ *
  * @author imi
+ * @author Frederik Ramm <frederik@remote.org>
  */
 public class OsmPrimitivRenderer extends DefaultListCellRenderer {
+public class OsmPrimitivRenderer implements ListCellRenderer, TableCellRenderer {
+        /**
+         * NameVisitor provides proper names and icons for OsmPrimitives
+         */
         private NameVisitor visitor = new NameVisitor();
+        @Override public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
+                super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
+                if (value != null) {
+        /**
+         * Default list cell renderer - delegate for ListCellRenderer operation
+         */
+        private DefaultListCellRenderer defaultListCellRenderer = new DefaultListCellRenderer();
+        /**
+         * Default table cell renderer - delegate for TableCellRenderer operation
+         */
+        private DefaultTableCellRenderer defaultTableCellRenderer = new DefaultTableCellRenderer();
+        /**
+         * Adapter method supporting the ListCellRenderer interface.
+         */
+        public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
+                Component def = defaultListCellRenderer.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
+                return renderer(def, (OsmPrimitive) value);
+        }
+        /**
+         * Adapter method supporting the TableCellRenderer interface.
+         */
+        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
+                Component def = defaultTableCellRenderer.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
+                return renderer(def, (OsmPrimitive) value);
+        }
+        /**
+         * Internal method that stuffs information into the rendering component
+         * provided that it's a kind of JLabel.
+         * @param def the rendering component
+         * @param value the OsmPrimtive to render
+         * @return the modified rendering component
+         */
+        private Component renderer(Component def, OsmPrimitive value) {
+                if (def != null && value != null && def instanceof JLabel) {
                         ((OsmPrimitive)value).visit(visitor);
                         setText(visitor.name);
                         setIcon(visitor.icon);
+                        ((JLabel)def).setText(visitor.name);
+                        ((JLabel)def).setIcon(visitor.icon);
+                }
                 return this;
+                return def;
+        }
+}

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/gui/SelectionManager.java

-              r4437
+              r4464
 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;
 …
          * modifier.
          * @param alt Whether the alt key was pressed, which means select all objects
+         *              that are touched, instead those which are completly covered. Also
+         *              select whole ways instead of segments.
+         *              that are touched, instead those which are completly covered.
          */
         public Collection<OsmPrimitive> getObjectsInRectangle(Rectangle r, boolean alt) {
 …
                 if (clicked) {
                         OsmPrimitive osm = nc.getNearest(center, alt);
+                        OsmPrimitive osm = nc.getNearest(center);
                         if (osm != null)
                                 selection.add(osm);
 …
+                        }
-                        // pending segments
-                        for (Segment s : Main.ds.segments)
-                                if (!s.deleted && rectangleContainSegment(r, alt, s))
-                                        selection.add(s);
                         // ways
                         for (Way w : Main.ds.ways) {
+                                if (w.deleted)
+                                        continue;
+                                boolean someSelectableSegment = false;
+                                boolean wholeWaySelected = true;
+                                for (Segment s : w.segments) {
+                                        if (s.incomplete)
+                                if (w.deleted || w.nodes.isEmpty())
                                                 continue;
+                                        someSelectableSegment = true;
+                                        if (!rectangleContainSegment(r, alt, s)) {
+                                                wholeWaySelected = false;
+                                if (alt) {
+                                        for (Node n : w.nodes) {
+                                                if (r.contains(nc.getPoint(n.eastNorth))) {
+                                                        selection.add(w);
                                                 break;
+                                        }
+                                }
+                                if (someSelectableSegment && wholeWaySelected)
+                                        selection.add(w);
+                                } else {
+                                        boolean allIn = true;
+                                        for (Node n : w.nodes) {
+                                                if (!r.contains(nc.getPoint(n.eastNorth))) {
+                                                        allIn = false;
+                                                        break;
+                        }
+                }
+                                        if (allIn) selection.add(w);
+                                }
+        }
+                }
                 return selection;
+        }
-        /**
-         * Decide whether the segment is in the rectangle Return
-         * <code>true</code>, if it is in or false if not.
+         *
-         * @param r                     The rectangle, in which the segment has to be.
-         * @param alt           Whether user pressed the Alt key
-         * @param ls            The segment.
-         * @return <code>true</code>, if the Segment was added to the selection.
-         */
-        private boolean rectangleContainSegment(Rectangle r, boolean alt, Segment ls) {
-                if (ls.incomplete)
-                        return false;
-                if (alt) {
-                        Point p1 = nc.getPoint(ls.from.eastNorth);
-                        Point p2 = nc.getPoint(ls.to.eastNorth);
-                        if (r.intersectsLine(p1.x, p1.y, p2.x, p2.y))
-                                return true;
-                } else {
-                        if (r.contains(nc.getPoint(ls.from.eastNorth))
-                                        && r.contains(nc.getPoint(ls.to.eastNorth)))
-                                return true;
+                }
-                return false;
+        }

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/gui/dialogs/ConflictDialog.java

-              r4437
+              r4464
 import org.openstreetmap.josm.data.SelectionChangedListener;
 import org.openstreetmap.josm.data.osm.DataSet;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.RelationMember;
 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.SimplePaintVisitor;
 …
                 add(buttonPanel, BorderLayout.SOUTH);
                 DataSet.listeners.add(new SelectionChangedListener(){
+                DataSet.selListeners.add(new SelectionChangedListener(){
                         public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
                                 displaylist.clearSelection();
 …
                                 model.addElement(osm);
                 for (OsmPrimitive osm : this.conflicts.keySet())
-                        if (osm instanceof Segment)
-                                model.addElement(osm);
-                for (OsmPrimitive osm : this.conflicts.keySet())
                         if (osm instanceof Way)
                                 model.addElement(osm);
 …
                                 g.drawRect(p.x-1, p.y-1, 2, 2);
+                        }
+                        public void visit(Segment ls) {
+                                if (ls.incomplete)
+                                        return;
+                                Point p1 = nc.getPoint(ls.from.eastNorth);
+                                Point p2 = nc.getPoint(ls.to.eastNorth);
+                        public void visit(Node n1, Node n2) {
+                                Point p1 = nc.getPoint(n1.eastNorth);
+                                Point p2 = nc.getPoint(n2.eastNorth);
                                 g.drawLine(p1.x, p1.y, p2.x, p2.y);
+                        }
                         public void visit(Way w) {
+                                for (Segment ls : w.segments)
+                                        visit(ls);
+                                Node lastN = null;
+                                for (Node n : w.nodes) {
+                                        if (lastN == null) {
+                                                lastN = n;
+                                                continue;
+                                        }
+                                        visit(lastN, n);
+                                        lastN = n;
+                                }
+                        }
+                        public void visit(Relation e) {
+                                for (RelationMember em : e.members)
+                                        em.member.visit(this);
+                        }
                 };

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/gui/dialogs/HistoryDialog.java

r4437	r4464
144	144	revertButton.putClientProperty("help", "Dialog/History/Revert");
145	145
146		DataSet.listeners.add(this);
	146	DataSet.selListeners.add(this);
147	147	}
148	148

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/gui/dialogs/PropertiesDialog.java

-              r4437
+              r4464
 import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.RelationMember;
+import org.openstreetmap.josm.data.osm.visitor.NameVisitor;
 import org.openstreetmap.josm.gui.MapFrame;
 import org.openstreetmap.josm.gui.preferences.TaggingPresetPreference;
+import org.openstreetmap.josm.gui.tagging.ForwardActionListener;
 import org.openstreetmap.josm.gui.tagging.TaggingCellRenderer;
-import org.openstreetmap.josm.gui.tagging.ForwardActionListener;
 import org.openstreetmap.josm.gui.tagging.TaggingPreset;
 import org.openstreetmap.josm.tools.AutoCompleteComboBox;
 …
         /**
+         * Used to display relation names in the membership table
+         */
+        private NameVisitor nameVisitor = new NameVisitor();
+        /**
          * Watches for double clicks and from editing or new property, depending on the
          * location, the click was.
 …
                         if (e.getClickCount() < 2)
                                 return;
                         if (e.getSource() instanceof JScrollPane)
                                 add();
                         else {
+                        if (e.getSource() == propertyTable)
+                        {
                                 int row = propertyTable.rowAtPoint(e.getPoint());
+                                edit(row);
+                        }
+                }
+        }
+        /**
+         * Edit the value in the table row
+         * @param row   The row of the table, from which the value is edited.
+         */
+        void edit(int row) {
+                String key = data.getValueAt(row, 0).toString();
+                                if (row > -1) {
+                                        propertyEdit(row);
+                                        return;
+                        }
+                        } else if (e.getSource() == membershipTable) {
+                                int row = membershipTable.rowAtPoint(e.getPoint());
+                                if (row > -1) {
+                                        membershipEdit(row);
+                                        return;
+                                }
+                        }
+                        add();
+                }
+        }
+        /**
+         * Edit the value in the properties table row
+         * @param row The row of the table from which the value is edited.
+         */
+        void propertyEdit(int row) {
+                String key = propertyData.getValueAt(row, 0).toString();
                 Collection<OsmPrimitive> sel = Main.ds.getSelected();
                 if (sel.isEmpty()) {
 …
                 p.add(keyField, GBC.eol().fill(GBC.HORIZONTAL));
                 final JComboBox combo = (JComboBox)data.getValueAt(row, 1);
+                final JTextField valueField = new JTextField((String)propertyData.getValueAt(row, 1));
                 p.add(new JLabel(tr("Value")), GBC.std());
                 p.add(Box.createHorizontalStrut(10), GBC.std());
                 p.add(combo, GBC.eol().fill(GBC.HORIZONTAL));
+                p.add(valueField, GBC.eol().fill(GBC.HORIZONTAL));
                 final JOptionPane optionPane = new JOptionPane(panel, JOptionPane.QUESTION_MESSAGE, JOptionPane.OK_CANCEL_OPTION){
                         @Override public void selectInitialValue() {
                                 combo.requestFocusInWindow();
                                 combo.getEditor().selectAll();
+                                valueField.requestFocusInWindow();
+                                valueField.selectAll();
+                        }
                 };
                 final JDialog dlg = optionPane.createDialog(Main.parent, tr("Change values?"));
                 combo.getEditor().addActionListener(new ActionListener(){
+                valueField.addActionListener(new ActionListener(){
                         public void actionPerformed(ActionEvent e) {
                                 optionPane.setValue(JOptionPane.OK_OPTION);
 …
+                        }
                 });
-                String oldComboEntry = combo.getEditor().getItem().toString();
                 dlg.setVisible(true);
 …
                 if (answer == null || answer == JOptionPane.UNINITIALIZED_VALUE ||
                                 (answer instanceof Integer && (Integer)answer != JOptionPane.OK_OPTION)) {
+                        combo.getEditor().setItem(oldComboEntry);
+                        return;
+                }
+                String value = combo.getEditor().getItem().toString();
+                        return;
+                }
+                String value = valueField.getText();
                 if (value.equals(tr("<different>")))
                         return;
 …
+                }
-                if (!key.equals(newkey) || value == null)
                         selectionChanged(sel); // update whole table
                 Main.parent.repaint(); // repaint all - drawing could have been changed
+        }
+        /**
+         * This simply fires up an relation editor for the relation shown; everything else
+         * is the editor's business.
+         *
+         * @param row
+         */
+        void membershipEdit(int row) {
+                final RelationEditor editor = new RelationEditor((Relation)membershipData.getValueAt(row, 0));
+                editor.setVisible(true);
+        }
 …
+                        }
+                }
                 for (int i = 0; i < data.getRowCount(); ++i)
                         allData.remove(data.getValueAt(i, 0));
+                for (int i = 0; i < propertyData.getRowCount(); ++i)
+                        allData.remove(propertyData.getValueAt(i, 0));
                 final AutoCompleteComboBox keys = new AutoCompleteComboBox();
                 keys.setPossibleItems(allData.keySet());
 …
          */
         private void delete(int row) {
                 String key = data.getValueAt(row, 0).toString();
+                String key = propertyData.getValueAt(row, 0).toString();
                 Collection<OsmPrimitive> sel = Main.ds.getSelected();
                 Main.main.undoRedo.add(new ChangePropertyCommand(sel, key, null));
 …
          * The property data.
          */
         private final DefaultTableModel data = new DefaultTableModel(){
+        private final DefaultTableModel propertyData = new DefaultTableModel() {
                 @Override public boolean isCellEditable(int row, int column) {
                         return false;
+                }
                 @Override public Class<?> getColumnClass(int columnIndex) {
                         return columnIndex == 1 ? JComboBox.class : String.class;
+                        return String.class;
+                }
         };
+        /**
+         * The membership data.
+         */
+        private final DefaultTableModel membershipData = new DefaultTableModel() {
+                @Override public boolean isCellEditable(int row, int column) {
+                        return false;
+                }
+                @Override public Class<?> getColumnClass(int columnIndex) {
+                        return columnIndex == 1 ? Relation.class : String.class;
+                }
+        };
         /**
          * The properties list.
          */
+        private final JTable propertyTable = new JTable(data);
+        private final JTable propertyTable = new JTable(propertyData);
+        private final JTable membershipTable = new JTable(membershipData);
         public JComboBox taggingPresets = new JComboBox();
 …
          */
         public PropertiesDialog(MapFrame mapFrame) {
                 super(tr("Properties"), "propertiesdialog", tr("Properties for selected objects."), KeyEvent.VK_P, 150);
+                super(tr("Properties/Memberships"), "propertiesdialog", tr("Properties for selected objects."), KeyEvent.VK_P, 150);
                 if (TaggingPresetPreference.taggingPresets.size() > 0) {
 …
                 taggingPresets.setRenderer(new TaggingCellRenderer());
+                data.setColumnIdentifiers(new String[]{tr("Key"),tr("Value")});
+                // setting up the properties table
+                propertyData.setColumnIdentifiers(new String[]{tr("Key"),tr("Value")});
                 propertyTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+                propertyTable.setDefaultRenderer(JComboBox.class, new DefaultTableCellRenderer(){
+                propertyTable.getColumnModel().getColumn(1).setCellRenderer(new DefaultTableCellRenderer(){
                         @Override public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
                                 Component c = super.getTableCellRendererComponent(table, value, isSelected, false, row, column);
                                 if (c instanceof JLabel) {
                                         String str = ((JComboBox)value).getEditor().getItem().toString();
+                                        String str = (String) value;
                                         ((JLabel)c).setText(str);
                                         if (str.equals(tr("<different>")))
 …
+                        }
                 });
+                propertyTable.setDefaultRenderer(String.class, new DefaultTableCellRenderer(){
+                // setting up the membership table
+                membershipData.setColumnIdentifiers(new String[]{tr("Member Of"),tr("Role")});
+                membershipTable.setRowSelectionAllowed(false);
+                membershipTable.getColumnModel().getColumn(0).setCellRenderer(new DefaultTableCellRenderer() {
                         @Override public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
+                                return super.getTableCellRendererComponent(table, value, isSelected, false, row, column);
+                                Component c = super.getTableCellRendererComponent(table, value, isSelected, false, row, column);
+                                if (c instanceof JLabel) {
+                                        nameVisitor.visit((Relation)value);
+                                        ((JLabel)c).setText(nameVisitor.name);
+                                }
+                                return c;
+                        }
                 });
+                // combine both tables and wrap them in a scrollPane
+                JPanel bothTables = new JPanel();
+                bothTables.setLayout(new GridBagLayout());
+                bothTables.add(propertyTable.getTableHeader(), GBC.eol().fill(GBC.HORIZONTAL));
+                bothTables.add(propertyTable, GBC.eol().fill(GBC.BOTH));
+                bothTables.add(membershipTable.getTableHeader(), GBC.eol().fill(GBC.HORIZONTAL));
+                bothTables.add(membershipTable, GBC.eol().fill(GBC.BOTH));
                 DblClickWatch dblClickWatch = new DblClickWatch();
                 propertyTable.addMouseListener(dblClickWatch);
+                JScrollPane scrollPane = new JScrollPane(propertyTable);
+                membershipTable.addMouseListener(dblClickWatch);
+                JScrollPane scrollPane = new JScrollPane(bothTables);
                 scrollPane.addMouseListener(dblClickWatch);
                 add(scrollPane, BorderLayout.CENTER);
 …
                                                 JOptionPane.showMessageDialog(Main.parent, tr("Please select the row to edit."));
                                         else
                                                 edit(sel);
+                                                propertyEdit(sel);
                                 } else if (e.getActionCommand().equals("Delete")) {
                                         if (sel == -1)
 …
+                        }
                 };
                 buttonPanel.add(createButton(marktr("Add"),tr("Add a new key/value pair to all objects"), KeyEvent.VK_A, buttonAction));
                 buttonPanel.add(createButton(marktr("Edit"),tr( "Edit the value of the selected key for all objects"), KeyEvent.VK_E, buttonAction));
 …
                 add(buttonPanel, BorderLayout.SOUTH);
                 DataSet.listeners.add(this);
+                DataSet.selListeners.add(this);
+        }
 …
                 if (propertyTable.getCellEditor() != null)
                         propertyTable.getCellEditor().cancelCellEditing();
+                data.setRowCount(0);
+                // re-load property data
+                propertyData.setRowCount(0);
                 Map<String, Integer> valueCount = new HashMap<String, Integer>();
 …
+                }
                 for (Entry<String, Collection<String>> e : props.entrySet()) {
+                        JComboBox value = new JComboBox(e.getValue().toArray());
+                        value.setEditable(true);
+                        value.getEditor().setItem(e.getValue().size() > 1 || valueCount.get(e.getKey()) != newSelection.size() ? tr("<different>") : e.getValue().iterator().next());
+                        data.addRow(new Object[]{e.getKey(), value});
+                        String value=(e.getValue().size() > 1 || valueCount.get(e.getKey()) != newSelection.size() ? tr("<different>") : e.getValue().iterator().next());
+                        propertyData.addRow(new Object[]{e.getKey(), value});
+                }
+                // re-load membership data
+                // this is rather expensive since we have to walk through all members of all existing relationships.
+                // could use back references here for speed if necessary.
+                membershipData.setRowCount(0);
+                Map<Relation, Integer> valueCountM = new HashMap<Relation, Integer>();
+                TreeMap<Relation, Collection<String>> roles = new TreeMap<Relation, Collection<String>>();
+                for (Relation r : Main.ds.relations) {
+                        for (RelationMember m : r.members) {
+                                if (newSelection.contains(m.member)) {
+                                        Collection<String> value = roles.get(r);
+                                        if (value == null) {
+                                                value = new TreeSet<String>();
+                                                roles.put(r, value);
+                                        }
+                                        value.add(m.role);
+                                        valueCountM.put(r, valueCount.containsKey(r) ? valueCount.get(r)+1 : 1);
+                                }
+                        }
+                }
+                for (Entry<Relation, Collection<String>> e : roles.entrySet()) {
+                        //JComboBox value = new JComboBox(e.getValue().toArray());
+                        //value.setEditable(true);
+                        //value.getEditor().setItem(e.getValue().size() > 1 || valueCount.get(e.getKey()) != newSelection.size() ? tr("<different>") : e.getValue().iterator().next());
+                        String value = e.getValue().size() > 1 || valueCountM.get(e.getKey()) != newSelection.size() ? tr("<different>") : e.getValue().iterator().next();
+                        membershipData.addRow(new Object[]{e.getKey(), value});
+                }
+        }

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/gui/dialogs/SelectionListDialog.java

r4437	r4464
80	80	selectionChanged(Main.ds.getSelected());
81	81
82		DataSet.listeners.add(this);
	82	DataSet.selListeners.add(this);
83	83	}
84	84

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/gui/dialogs/UserListDialog.java

r4437	r4464
54	54	selectionChanged(Main.ds.getSelected());
55	55
56		DataSet.listeners.add(this);
	56	DataSet.selListeners.add(this);
57	57	}
58	58

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/gui/layer/OsmDataLayer.java

-              r4437
+              r4464
 import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.data.osm.DataSource;
+import org.openstreetmap.josm.data.osm.Relation;
 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.BoundingXYVisitor;
 …
                 public final int[] normal = new int[3];
                 public final int[] deleted = new int[3];
                 public final String[] names = {"node", "segment", "way"};
+                public final String[] names = {"node", "way", "relation"};
                 private void inc(final OsmPrimitive osm, final int i) {
 …
+                }
-                public void visit(final Segment ls) {
-                        inc(ls, 1);
+                }
                 public void visit(final Way w) {
+                        inc(w, 1);
+                }
+                public void visit(final Relation w) {
                         inc(w, 2);
+                }
 …
          * Draw all primitives in this layer but do not draw modified ones (they
          * are drawn by the edit layer).
          * Draw nodes last to overlap the segments they belong to.
+         * Draw nodes last to overlap the ways they belong to.
          */
         @Override public void paint(final Graphics g, final MapView mv) {
 …
                 String tool = "";
                 tool += undeletedSize(data.nodes)+" "+trn("node", "nodes", undeletedSize(data.nodes))+", ";
-                tool += undeletedSize(data.segments)+" "+trn("segment", "segments", undeletedSize(data.segments))+", ";
                 tool += undeletedSize(data.ways)+" "+trn("way", "ways", undeletedSize(data.ways));
                 if (associatedFile != null)
 …
                         for (final Iterator<Node> it = data.nodes.iterator(); it.hasNext();)
                                 cleanIterator(it, processedSet);
-                        for (final Iterator<Segment> it = data.segments.iterator(); it.hasNext();)
-                                cleanIterator(it, processedSet);
                         for (final Iterator<Way> it = data.ways.iterator(); it.hasNext();)
                                 cleanIterator(it, processedSet);

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/gui/layer/RawGpsLayer.java

-              r4437
+              r4464
 import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.data.osm.Node;
-import org.openstreetmap.josm.data.osm.Segment;
 import org.openstreetmap.josm.data.osm.Way;
 import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
 …
                         for (Collection<GpsPoint> c : data) {
                                 Way w = new Way();
-                                Node start = null;
                                 for (GpsPoint p : c) {
+                                        Node end = new Node(p.latlon);
+                                        ds.nodes.add(end);
+                                        if (start != null) {
+                                                Segment segment = new Segment(start,end);
+                                                w.segments.add(segment);
+                                                ds.segments.add(segment);
+                                        }
+                                        start = end;
+                                        Node n = new Node(p.latlon);
+                                        ds.nodes.add(n);
+                                        w.nodes.add(n);
+                                }
                                 ds.ways.add(w);

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/io/BoundingBoxDownloader.java

r4437	r4464
103	103	Main.pleaseWaitDlg.currentAction.setText(tr("Downloading OSM data..."));
104	104	final DataSet data = OsmReader.parseDataSet(in, null, Main.pleaseWaitDlg);
105		String origin = Main.pref.get("osm-server.url")+"/"+Main.pref.get("osm-server.version", "0.4");
	105	String origin = Main.pref.get("osm-server.url")+"/"+Main.pref.get("osm-server.version", "0.5");
106	106	Bounds bounds = new Bounds(new LatLon(lat1, lon1), new LatLon(lat2, lon2));
107	107	DataSource src = new DataSource(bounds, origin);

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/io/GpxWriter.java

-              r4437
+              r4464
 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.layer.RawGpsLayer.GpsPoint;
 …
         /**
+         * Export the dataset to gpx. Only the physical segment structure is
+         * exported. To do this, the list of ways is processed. If a way span a
+         * sequence of segments, this is added as one trkseg.
+         * Then, all remaining segments are added in one extra trk. Finally,
+         * all remaining nodes are added as wpt.
+         * Export the dataset to gpx.  The ways are converted to trksegs, each in
+         * a seperate trk.  Finally, all remaining nodes are added as wpt.
          */
         public static final class All implements XmlWriter.OsmWriterInterface {
 …
                                         continue;
                                 out.println("  <trk>");
-                                Segment oldLs = null;
-                                for (Segment ls : w.segments) {
-                                        if (ls.incomplete)
-                                                continue;
-                                        // end old segemnt, if no longer match a chain
-                                        if (oldLs != null && !oldLs.to.coor.equals(ls.from.coor)) {
-                                                out.println("    </trkseg>");
-                                                writer.outputNode(oldLs.to, false);
-                                                all.remove(oldLs.to);
-                                                oldLs = null;
+                                        }
-                                        // start new segment if necessary
-                                        if (oldLs == null)
                                                 out.println("    <trkseg>");
+                                        writer.outputNode(ls.from, false);
+                                        all.remove(ls.from);
+                                        oldLs = ls;
+                                        all.remove(ls);
+                                }
+                                // write last node if there
+                                if (oldLs != null) {
+                                        writer.outputNode(oldLs.to, false);
+                                        all.remove(oldLs.to);
+                                for (Node n : w.nodes) {
+                                        writer.outputNode(n, false);
+                                        all.remove(n);
+                        }
                                         out.println("    </trkseg>");
+                                }
                                 out.println("  </trk>");
                                 all.remove(w);
+                        }
-                        // add remaining segments
-                        Collection<Segment> segments = new LinkedList<Segment>();
-                        for (OsmPrimitive osm : all)
-                                if (osm instanceof Segment && !((Segment)osm).incomplete)
-                                        segments.add((Segment)osm);
-                        if (!segments.isEmpty()) {
-                                out.println("  <trk>");
-                                for (Segment ls : segments) {
-                                        out.println("    <trkseg>");
-                                        writer.outputNode(ls.from, false);
-                                        all.remove(ls.from);
-                                        writer.outputNode(ls.to, false);
-                                        all.remove(ls.to);
-                                        out.println("    </trkseg>");
-                                        all.remove(ls);
+                                }
-                                out.println("  </trk>");
+                        }

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/io/OsmIdReader.java

r4437	r4464
28	28
29	29	@Override public void startElement(String namespaceURI, String localName, String qName, Attributes atts) throws SAXException {
30		if (qName.equals("node") \|\| qName.equals("~~segment") \|\| qName.equals("~~way")) {
	30	if (qName.equals("node") \|\| qName.equals("way")) {
31	31	try {
32	32	entries.put(Long.valueOf(atts.getValue("id")), qName);

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/io/OsmReader.java

-              r4437
+              r4464
 import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.data.osm.DataSource;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.RelationMember;
 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.User;
 import org.openstreetmap.josm.data.osm.Way;
 …
  * all nodes are read and stored. Other information than nodes are stored in a raw list
+ *
+ * The second phase reads from the raw list all segments and create Segment objects.
+ *
+ * The third phase read all ways out of the remaining objects in the raw list.
+ * The second phase read all ways out of the remaining objects in the raw list.
+ *
  * @author Imi
 …
         /**
+         * Data structure for the remaining segment objects
+         * Maps the raw attributes to key/value pairs.
+         */
+        private Map<OsmPrimitiveData, long[]> segs = new HashMap<OsmPrimitiveData, long[]>();
+         * Used as a temporary storage for relation members, before they
+         * are resolved into pointers to real objects.
+         */
+        private static class RelationMemberData {
+                public String type;
+                public long id;
+                public RelationMember relationMember;
+        }
         /**
 …
          */
         private Map<OsmPrimitiveData, Collection<Long>> ways = new HashMap<OsmPrimitiveData, Collection<Long>>();
+        /**
+         * Data structure for relation objects
+         */
+        private Map<OsmPrimitiveData, Collection<RelationMemberData>> relations = new HashMap<OsmPrimitiveData, Collection<RelationMemberData>>();
         /**
 …
                                                 ds.dataSources.add(src);
+                                        }
+                                // ---- PARSING NODES AND WAYS ----
                                 } else if (qName.equals("node")) {
                                         current = new Node(new LatLon(getDouble(atts, "lat"), getDouble(atts, "lon")));
                                         readCommon(atts, current);
                                         nodes.put(current.id, (Node)current);
-                                } else if (qName.equals("segment")) {
-                                        current = new OsmPrimitiveData();
-                                        readCommon(atts, current);
-                                        segs.put((OsmPrimitiveData)current, new long[]{getLong(atts, "from"), getLong(atts, "to")});
                                 } else if (qName.equals("way")) {
                                         current = new OsmPrimitiveData();
                                         readCommon(atts, current);
                                         ways.put((OsmPrimitiveData)current, new LinkedList<Long>());
                                 } else if (qName.equals("seg")) {
+                                } else if (qName.equals("nd")) {
                                         Collection<Long> list = ways.get(current);
                                         if (list == null)
                                                 throw new SAXException(tr("Found <seg> tag on non-way."));
                                         long id = getLong(atts, "id");
+                                                throw new SAXException(tr("Found <nd> element in non-way."));
+                                        long id = getLong(atts, "ref");
                                         if (id == 0)
                                                 throw new SAXException(tr("Incomplete segment with id=0"));
+                                                throw new SAXException(tr("<nd> has zero ref"));
                                         list.add(id);
+                                } else if (qName.equals("tag"))
+                                // ---- PARSING ENTITIES ----
+                                } else if (qName.equals("relation")) {
+                                        current = new OsmPrimitiveData();
+                                        readCommon(atts, current);
+                                        relations.put((OsmPrimitiveData)current, new LinkedList<RelationMemberData>());
+                                } else if (qName.equals("member")) {
+                                        Collection<RelationMemberData> list = relations.get(current);
+                                        if (list == null)
+                                                throw new SAXException(tr("Found <member> tag on non-relation."));
+                                        RelationMemberData emd = new RelationMemberData();
+                                        emd.relationMember = new RelationMember();
+                                        emd.id = getLong(atts, "ref");
+                                        emd.type=atts.getValue("type");
+                                        emd.relationMember.role = atts.getValue("role");
+                                        if (emd.id == 0)
+                                                throw new SAXException(tr("Incomplete <member> specification with ref=0"));
+                                        list.add(emd);
+                                // ---- PARSING TAGS (applicable to all objects) ----
+                                } else if (qName.equals("tag")) {
                                         current.put(atts.getValue("k"), atts.getValue("v"));
+                                }
                         } catch (NumberFormatException x) {
                                 x.printStackTrace(); // SAXException does not chain correctly
 …
         public OsmReader() {
                 // first add the main server version
                 allowedVersions.add(Main.pref.get("osm-server.version", "0.4"));
+                allowedVersions.add(Main.pref.get("osm-server.version", "0.5"));
                 // now also add all compatible versions
                 String[] additionalVersions =
+                        Main.pref.get("osm-server.additional-versions", "0.3").split("/,/");
+                        Main.pref.get("osm-server.additional-versions", "").split("/,/");
+                if (additionalVersions.length == 1 && additionalVersions[0].length() == 0)
+                        additionalVersions = new String[] {};
                 allowedVersions.addAll(Arrays.asList(additionalVersions));
+        }
 …
                         throw new SAXException(tr("Missing required attribute \"{0}\".",value));
                 return Long.parseLong(s);
+        }
-        private void createSegments() {
-                for (Entry<OsmPrimitiveData, long[]> e : segs.entrySet()) {
-                        Node from = findNode(e.getValue()[0]);
-                        Node to = findNode(e.getValue()[1]);
-                        if (from == null || to == null)
-                                continue; //TODO: implement support for incomplete nodes.
-                        Segment s = new Segment(from, to);
-                        e.getKey().copyTo(s);
-                        segments.put(s.id, s);
-                        adder.visit(s);
+                }
+        }
 …
+    }
-        private Segment findSegment(long id) {
-                Segment s = segments.get(id);
-                if (s != null)
-                        return s;
-                for (Segment seg : references.segments)
-                        if (seg.id == id)
-                                return seg;
-                // TODO: This has to be changed to support multiple layers.
-                for (Segment seg : Main.ds.segments)
-                        if (seg.id == id)
-                                return new Segment(seg);
-                return null;
+        }
         private void createWays() {
                 for (Entry<OsmPrimitiveData, Collection<Long>> e : ways.entrySet()) {
                         Way w = new Way();
+                        boolean failed = false;
                         for (long id : e.getValue()) {
                                 Segment s = findSegment(id);
                                 if (s == null) {
                                         s = new Segment(id); // incomplete line segment
                                         adder.visit(s);
+                                Node n = findNode(id);
+                                if (n == null) {
+                                        failed = true;
+                                        break;
+                                }
                                 w.segments.add(s);
+                                w.nodes.add(n);
+                        }
+                        if (failed) continue;
                         e.getKey().copyTo(w);
                         adder.visit(w);
 …
         /**
+         * All read segments after phase 2.
+         */
+        private Map<Long, Segment> segments = new HashMap<Long, Segment>();
+         * Return the Way object with the given id, or null if it doesn't
+         * exist yet. This method only looks at ways stored in the data set.
+         *
+         * @param id
+         * @return way object or null
+         */
+        private Way findWay(long id) {
+                for (Way wy : ds.ways)
+                        if (wy.id == id)
+                                return wy;
+                for (Way wy : Main.ds.ways)
+                        if (wy.id == id)
+                                return wy;
+                return null;
+        }
+        /**
+         * Return the Relation object with the given id, or null if it doesn't
+         * exist yet. This method only looks at relations stored in the data set.
+         *
+         * @param id
+         * @return relation object or null
+         */
+        private Relation findRelation(long id) {
+                for (Relation e : ds.relations)
+                        if (e.id == id)
+                                return e;
+                for (Relation e : Main.ds.relations)
+                        if (e.id == id)
+                                return e;
+                return null;
+        }
+        /**
+         * Create relations. This is slightly different than n/s/w because
+         * unlike other objects, relations may reference other relations; it
+         * is not guaranteed that a referenced relation will have been created
+         * before it is referenced. So we have to create all relations first,
+         * and populate them later.
+         */
+        private void createRelations() {
+                // pass 1 - create all relations
+                for (Entry<OsmPrimitiveData, Collection<RelationMemberData>> e : relations.entrySet()) {
+                        Relation en = new Relation();
+                        e.getKey().copyTo(en);
+                        adder.visit(en);
+                }
+                // pass 2 - sort out members
+                for (Entry<OsmPrimitiveData, Collection<RelationMemberData>> e : relations.entrySet()) {
+                        Relation en = findRelation(e.getKey().id);
+                        if (en == null) throw new Error("Failed to create relation " + e.getKey().id);
+                        for (RelationMemberData emd : e.getValue()) {
+                                RelationMember em = emd.relationMember;
+                                if (emd.type.equals("node")) {
+                                        em.member = findNode(emd.id);
+                                        if (em.member == null) {
+                                                em.member = new Node(emd.id);
+                                                adder.visit((Node)em.member);
+                                        }
+                                } else if (emd.type.equals("way")) {
+                                        em.member = findWay(emd.id);
+                                        if (em.member == null) {
+                                                em.member = new Way(emd.id);
+                                                adder.visit((Way)em.member);
+                                        }
+                                } else if (emd.type.equals("relation")) {
+                                        em.member = findRelation(emd.id);
+                                        if (em.member == null) {
+                                                em.member = new Relation(emd.id);
+                                                adder.visit((Relation)em.member);
+                                        }
+                                } else {
+                                        // this is an error.
+                                }
+                                en.members.add(em);
+                        }
+                }
+        }
         /**
 …
                 osm.references = ref == null ? new DataSet() : ref;
                 // phase 1: Parse nodes and read in raw segments and ways
+                // phase 1: Parse nodes and read in raw ways
                 osm.new Parser().parse(new InputStreamReader(source, "UTF-8"));
                 if (pleaseWaitDlg != null) {
 …
                 try {
-                        osm.createSegments();
                         osm.createWays();
+                        osm.createRelations();
                 } catch (NumberFormatException e) {
                         e.printStackTrace();

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/io/OsmServerReader.java

r4437	r4464
30	30	*/
31	31	protected InputStream getInputStream(String urlStr, PleaseWaitDialog pleaseWaitDlg) throws IOException {
32		String version = Main.pref.get("osm-server.version", "0.4");
	32	String version = Main.pref.get("osm-server.version", "0.5");
33	33	urlStr = Main.pref.get("osm-server.url")+"/"+version+"/" + urlStr;
34	34	System.out.println("download: "+urlStr);

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/io/OsmServerWriter.java

-              r4437
+              r4464
 import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.data.osm.Relation;
 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.NameVisitor;
 …
         /**
+         * Upload a segment (without the nodes).
+         */
+        public void visit(Segment ls) {
+                if (ls.id == 0 && !ls.deleted && ls.get("created_by") == null) {
+                        ls.put("created_by", "JOSM");
+                        sendRequest("PUT", "segment", ls, true);
+                } else if (ls.deleted) {
+                        sendRequest("DELETE", "segment", ls, false);
+                } else {
+                        sendRequest("PUT", "segment", ls, true);
+                }
+                processed.add(ls);
+        }
+        /**
+         * Upload a whole way with the complete segment id list.
+         * Upload a whole way with the complete node id list.
          */
         public void visit(Way w) {
 …
+        }
+        /**
+         * Upload an relation with all members.
+         */
+        public void visit(Relation e) {
+                if (e.id == 0 && !e.deleted && e.get("created_by") == null) {
+                        e.put("created_by", "JOSM");
+                        sendRequest("PUT", "relation", e, true);
+                } else if (e.deleted) {
+                        sendRequest("DELETE", "relation", e, false);
+                } else {
+                        sendRequest("PUT", "relation", e, true);
+                }
+                processed.add(e);
+        }
         /**
          * Read a long from the input stream and return it.
 …
                         OsmPrimitive osm, boolean addBody) {
                 try {
                         String version = Main.pref.get("osm-server.version", "0.4");
+                        String version = Main.pref.get("osm-server.version", "0.5");
                         URL url = new URL(
                                         Main.pref.get("osm-server.url") +
                                         "/" + version +
                                         "/" + urlSuffix +
                                         "/" + ((version.equals("0.4") && osm.id==0) ? "create":osm.id));
+                                        "/" + (osm.id==0 ? "create" : osm.id));
                         System.out.println("upload to: "+url);
                         activeConnection = (HttpURLConnection)url.openConnection();

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/io/OsmWriter.java

-              r4437
+              r4464
 import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.data.osm.DataSource;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.RelationMember;
 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.Visitor;
 …
                 public void header(PrintWriter out) {
                         out.print("<osm version='");
                         out.print(Main.pref.get("osm-server.version", "0.4"));
+                        out.print(Main.pref.get("osm-server.version", "0.5"));
                         out.println("' generator='JOSM'>");
+                }
 …
+                }
+        }
+        // simple helper to write the object's class to the out stream
+        private Visitor typeWriteVisitor = new Visitor() {
+                public void visit(Node n) { out.print("node"); }
+                public void visit(Way w) { out.print("way"); }
+                public void visit(Relation e) { out.print("relation"); }
+        };
         /**
 …
                                 if (shouldWrite(n))
                                         writer.visit(n);
-                        for (Segment ls : ds.segments)
-                                if (shouldWrite(ls))
-                                        writer.visit(ls);
                         for (Way w : ds.ways)
                                 if (shouldWrite(w))
                                         writer.visit(w);
+                        for (Relation e : ds.relations)
+                                if (shouldWrite(e))
+                                        writer.visit(e);
+        }
 …
+        }
-        public void visit(Segment ls) {
-                if (ls.incomplete)
-                        return; // Do not write an incomplete segment
-                addCommon(ls, "segment");
-                out.print(" from='"+getUsedId(ls.from)+"' to='"+getUsedId(ls.to)+"'");
-                addTags(ls, "segment", true);
+        }
         public void visit(Way w) {
                 addCommon(w, "way");
                 out.println(">");
                 for (Segment ls : w.segments)
                         out.println("    <seg id='"+getUsedId(ls)+"' />");
+                for (Node n : w.nodes)
+                        out.println("    <nd ref='"+getUsedId(n)+"' />");
                 addTags(w, "way", false);
+        }
+        public void visit(Relation e) {
+                addCommon(e, "relation");
+                out.println(">");
+                for (RelationMember em : e.members) {
+                        out.print("    <member type='");
+                        em.member.visit(typeWriteVisitor);
+                        out.println("' ref='"+getUsedId(em.member)+"' role='" +
+                                XmlWriter.encode(em.role) + "' />");
+                }
+                addTags(e, "relation", false);
+        }
         /**

applications/editors/josm/core_0.5/src/org/openstreetmap/josm/io/XmlWriter.java

r4437	r4464
67	67	}
68	68
69
70
71	69	/**
72	70	* The output writer to save the values to.

Context Navigation

Changeset 4464 in osm

Legend:

Download in other formats: