Index: /.classpath =================================================================== --- /.classpath (revision 134) +++ /.classpath (revision 135) @@ -2,7 +2,8 @@ - + + - + Index: /build.xml =================================================================== --- /build.xml (revision 134) +++ /build.xml (revision 135) @@ -31,5 +31,5 @@ - + Index: /src/org/openstreetmap/josm/actions/GroupAction.java =================================================================== --- /src/org/openstreetmap/josm/actions/GroupAction.java (revision 134) +++ /src/org/openstreetmap/josm/actions/GroupAction.java (revision 135) @@ -3,4 +3,5 @@ import java.awt.event.ActionEvent; import java.awt.event.ActionListener; +import java.awt.event.KeyEvent; import java.beans.PropertyChangeEvent; import java.beans.PropertyChangeListener; @@ -8,4 +9,5 @@ import java.util.List; +import javax.swing.AbstractAction; import javax.swing.Action; import javax.swing.Icon; @@ -30,12 +32,8 @@ private PropertyChangeListener forwardActiveListener = new PropertyChangeListener(){ public void propertyChange(PropertyChangeEvent evt) { - if (evt.getPropertyName().equals("active")) { + if (evt.getPropertyName().equals("active")) putValue("active", evt.getNewValue()); - if (evt.getNewValue() == Boolean.FALSE) - cycle = false; - } } }; - public boolean cycle; protected void setCurrent(int current) { @@ -53,11 +51,12 @@ String idName = getClass().getName(); Main.contentPane.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke(shortCut, modifiers), idName); - Main.contentPane.getActionMap().put(idName, this); + Main.contentPane.getActionMap().put(idName, this); shortCutName = ShortCutLabel.name(shortCut, modifiers); - addPropertyChangeListener(new PropertyChangeListener(){ - public void propertyChange(PropertyChangeEvent evt) { - if (evt.getPropertyName().equals("active") && evt.getNewValue() == Boolean.FALSE) - cycle = false; - } + Main.contentPane.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke(shortCut, KeyEvent.SHIFT_DOWN_MASK), idName+".cycle"); + Main.contentPane.getActionMap().put(idName+".cycle", new AbstractAction(){ + public void actionPerformed(ActionEvent e) { + setCurrent((current+1)%actions.size()); + actions.get(current).actionPerformed(e); + } }); } @@ -68,11 +67,6 @@ b.setSelected(!b.isSelected()); openPopup(b); - } else { - if (cycle) - setCurrent((current+1)%actions.size()); - else - cycle = true; + } else actions.get(current).actionPerformed(e); - } } Index: /src/org/openstreetmap/josm/gui/MapMover.java =================================================================== --- /src/org/openstreetmap/josm/gui/MapMover.java (revision 134) +++ /src/org/openstreetmap/josm/gui/MapMover.java (revision 135) @@ -32,9 +32,10 @@ } public void actionPerformed(ActionEvent e) { - if (action.equals("+") || action.equals("-")) { + System.out.println("e="+e.toString()+" action="+e.getActionCommand()); + if (action.equals(".") || action.equals(",")) { Point mouse = nc.getMousePosition(); if (mouse == null) mouse = new Point((int)nc.getBounds().getCenterX(), (int)nc.getBounds().getCenterY()); - MouseWheelEvent we = new MouseWheelEvent(nc, e.getID(), e.getWhen(), e.getModifiers(), mouse.x, mouse.y, 0, false, MouseWheelEvent.WHEEL_UNIT_SCROLL, 1, action.equals("+") ? -1 : 1); + MouseWheelEvent we = new MouseWheelEvent(nc, e.getID(), e.getWhen(), e.getModifiers(), mouse.x, mouse.y, 0, false, MouseWheelEvent.WHEEL_UNIT_SCROLL, 1, action.equals(",") ? -1 : 1); mouseWheelMoved(we); } else { @@ -78,6 +79,6 @@ nc.addMouseWheelListener(this); - String[] n = {"+","-","up","right","down","left"}; - int[] k = {KeyEvent.VK_PLUS, KeyEvent.VK_MINUS, KeyEvent.VK_UP, KeyEvent.VK_RIGHT, KeyEvent.VK_DOWN, KeyEvent.VK_LEFT}; + String[] n = {",",".","up","right","down","left"}; + int[] k = {KeyEvent.VK_COMMA, KeyEvent.VK_PERIOD, KeyEvent.VK_UP, KeyEvent.VK_RIGHT, KeyEvent.VK_DOWN, KeyEvent.VK_LEFT}; for (int i = 0; i < n.length; ++i) { Index: /test/org/openstreetmap/josm/data/osm/visitor/MergeVisitorTest.java =================================================================== --- /test/org/openstreetmap/josm/data/osm/visitor/MergeVisitorTest.java (revision 135) +++ /test/org/openstreetmap/josm/data/osm/visitor/MergeVisitorTest.java (revision 135) @@ -0,0 +1,286 @@ +package org.openstreetmap.josm.data.osm.visitor; + +import java.util.Date; + +import junit.framework.TestCase; + +import org.openstreetmap.josm.data.coor.LatLon; +import org.openstreetmap.josm.data.osm.DataSet; +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.MergeVisitor; +import org.openstreetmap.josm.testframework.Bug; +import org.openstreetmap.josm.testframework.DataSetTestCaseHelper; + +public class MergeVisitorTest extends TestCase { + + + private DataSet ds; + private Node dsNode; + private Node n; + private MergeVisitor v; + + @Override protected void setUp() throws Exception { + ds = new DataSet(); + dsNode = DataSetTestCaseHelper.createNode(ds); + v = new MergeVisitor(ds); + n = DataSetTestCaseHelper.createNode(null); + } + + + public void testNodesMergeUpdate() { + dsNode.id = 1; + n.id = 1; + n.timestamp = new Date(); + v.visit(n); + assertEquals(dsNode, n); + } + public void testNodesMergeModified() { + dsNode.id = 1; + n.id = 1; + n.modified = true; + v.visit(n); + assertEquals(dsNode, n); + } + public void testNodesConflictBothModified() { + n.modified = true; + dsNode.modified = true; + n.id = 1; + dsNode.id = 1; + v.visit(n); + assertEquals(1, v.conflicts.size()); + } + public void testNodesConflict() { + dsNode.id = 1; + dsNode.timestamp = new Date(); + n.id = 1; + n.modified = true; + n.timestamp = new Date(dsNode.timestamp.getTime()-1); + v.visit(n); + assertEquals(1, v.conflicts.size()); + assertSame(dsNode, v.conflicts.keySet().iterator().next()); + assertSame(n, v.conflicts.values().iterator().next()); + } + public void testNodesConflict2() { + dsNode.id = 1; + dsNode.timestamp = new Date(); + dsNode.modified = true; + n.id = 1; + n.timestamp = new Date(dsNode.timestamp.getTime()+1); + v.visit(n); + assertEquals(1, v.conflicts.size()); + } + public void testNodesConflictModifyDelete() { + dsNode.id = 1; + dsNode.modified = true; + n.id = 1; + n.delete(true); + v.visit(n); + assertEquals(1, v.conflicts.size()); + } + public void testNodesMergeSamePosition() { + n.id = 1; // new node comes from server + dsNode.modified = true; // our node is modified + dsNode.coor = new LatLon(n.coor.lat(), n.coor.lon()); + v.visit(n); + v.fixReferences(); + assertEquals(0, v.conflicts.size()); + assertEquals(1, dsNode.id); + assertFalse("updating a new node clear the modified state", dsNode.modified); + } + + public void testNoConflictNewNodesMerged() { + assertEquals(0, n.id); + assertEquals(0, dsNode.id); + v.visit(n); + v.fixReferences(); + assertEquals(0,v.conflicts.size()); + assertTrue(ds.nodes.contains(n)); + assertEquals(2, ds.nodes.size()); + } + + /** + * Test that two new segments that have different from/to are not merged + */ + @Bug(101) + public void testNewSegmentNotMerged() { + v.visit(n); + Segment s1 = new Segment(n, dsNode); + v.visit(s1); + Segment s2 = new Segment(dsNode, n); + v.visit(s2); + assertEquals(2, ds.segments.size()); + } + + public void testFixReferencesConflicts() { + // make two nodes mergable + dsNode.id = 1; + n.id = 1; + n.timestamp = new Date(); + // have an old segment with the old node + Segment sold = new Segment(dsNode, dsNode); + sold.id = 23; + sold.modified = true; + ds.segments.add(sold); + // have a conflicting segment point to the new node + Segment s = new Segment(n,DataSetTestCaseHelper.createNode(null)); + s.id = 23; + s.modified = true; + + v.visit(n); // merge + assertEquals(n.timestamp, dsNode.timestamp); + v.visit(s); + assertEquals(1, v.conflicts.size()); + v.fixReferences(); + assertSame(s.from, dsNode); + } + + public void testNoConflictForSame() { + dsNode.id = 1; + dsNode.modified = true; + n.cloneFrom(dsNode); + v.visit(n); + assertEquals(0, v.conflicts.size()); + } + + /** + * Merge of an old segment with a new one. This should + * be mergable (if the nodes matches). + */ + public void testMergeOldSegmentsWithNew() { + Node[] n = createNodes(ds, 2); + Segment ls1 = DataSetTestCaseHelper.createSegment(ds, n[0], n[1]); + ls1.id = 3; + + Node newnode = new Node(new LatLon(n[1].coor.lat(), n[1].coor.lon())); + Segment newls = new Segment(n[0], newnode); + + v.visit(newls); + assertEquals("segment should have been merged.", 1, ds.segments.size()); + } + + /** + * Incomplete segments should always loose. + */ + public void testImportIncomplete() throws Exception { + Segment s1 = DataSetTestCaseHelper.createSegment(ds, dsNode, dsNode); + s1.id = 1; + Segment s2 = new Segment(s1); + s1.incomplete = true; + s2.timestamp = new Date(); + v.visit(s2); + assertTrue(s1.realEqual(s2)); + } + /** + * Incomplete segments should extend existing ways. + */ + public void testImportIncompleteExtendWays() throws Exception { + Segment s1 = DataSetTestCaseHelper.createSegment(ds, dsNode, dsNode); + Way w = DataSetTestCaseHelper.createWay(ds, new Segment[]{s1}); + s1.id = 1; + Segment s2 = new Segment(s1); + s1.incomplete = true; + v.visit(s2); + v.fixReferences(); + assertEquals(1, w.segments.size()); + assertEquals(s2, w.segments.get(0)); + assertFalse(s2.incomplete); + } + + + /** + * Nodes beeing merged are equal but should be the same. + */ + @Bug(54) + public void testEqualNotSame() { + ds = new DataSet(); + // create a dataset with segment a-b + Node n[] = createNodes(ds, 2); + Segment ls1 = DataSetTestCaseHelper.createSegment(ds, n[0], n[1]); + ls1.id = 1; + + // create an other dataset with segment a'-c (a' is equal, but not same to a) + DataSet ds2 = new DataSet(); + Node n2[] = createNodes(ds2, 2); + n2[0].coor = new LatLon(n[0].coor.lat(), n[0].coor.lon()); + n2[0].id = 0; + n2[1].id = 42; + + Segment ls2 = DataSetTestCaseHelper.createSegment(ds, n2[0], n2[1]); + v = new MergeVisitor(ds); + for (OsmPrimitive osm : ds2.allPrimitives()) + osm.visit(v); + v.fixReferences(); + + assertSame(ls1.from, ls2.from); + } + + + public void testCloneWayNotIncomplete() { + DataSet ds = new DataSet(); + Node[] n = createNodes(ds, 2); + Segment s = DataSetTestCaseHelper.createSegment(ds, n[0], n[1]); + Way w = DataSetTestCaseHelper.createWay(ds, s); + MergeVisitor v = new MergeVisitor(ds); + v.visit(n[0]); + v.visit(n[1]); + v.visit(s); + v.visit(w); + Way w2 = new Way(w); + w2.timestamp = new Date(); + Segment s2 = new Segment(s); + s2.incomplete = true; + w2.segments.clear(); + w2.segments.add(s2); + v.visit(w2); + assertSame("Do not import incomplete segments when merging ways.", s, w.segments.iterator().next()); + } + + /** + * When merging an incomplete way over a dataset that contain already all + * necessary segments, the way must be completed. + */ + @Bug(117) + public void testMergeIncompleteOnExistingDoesNotComplete() { + // create a dataset with an segment (as base for the later incomplete way) + DataSet ds = new DataSet(); + Node[] n = createNodes(ds, 2); + Segment s = DataSetTestCaseHelper.createSegment(ds, n[0], n[1]); + s.id = 23; + // create an incomplete way which references the former segment + Way w = new Way(); + Segment incompleteSegment = new Segment(s.id); + w.segments.add(incompleteSegment); + w.id = 42; + // merge both + MergeVisitor v = new MergeVisitor(ds); + v.visit(w); + v.fixReferences(); + + assertTrue(ds.ways.contains(w)); + assertEquals(1, w.segments.size()); + assertFalse(w.segments.get(0).incomplete); + } + + /** + * Deleted segments should be deleted when merged over unchanged segments. + * Deleted segments should also raise an conflict when merged over changed segments. + */ + //TODO + + /** + * Create that amount of nodes and add them to the dataset. The id will be 1,2,3,4... + * @param amount Number of nodes to create. + * @return The created nodes. + */ + private Node[] createNodes(DataSet ds, int amount) { + Node[] nodes = new Node[amount]; + for (int i = 0; i < amount; ++i) { + nodes[i] = DataSetTestCaseHelper.createNode(ds); + nodes[i].id = i+1; + } + return nodes; + } +} Index: /test/org/openstreetmap/josm/testframework/Bug.java =================================================================== --- /test/org/openstreetmap/josm/testframework/Bug.java (revision 135) +++ /test/org/openstreetmap/josm/testframework/Bug.java (revision 135) @@ -0,0 +1,13 @@ +package org.openstreetmap.josm.testframework; + +/** + * Annotation that indicate that a specific test case function was a bug. + * @author Imi + */ +public @interface Bug { + /** + * The revision this bug was detected. (Can be later than the actual first occourence. + * This number is just to have a revision where the bug actually happen.) + */ + int value(); +} Index: /test/org/openstreetmap/josm/testframework/DataSetTestCaseHelper.java =================================================================== --- /test/org/openstreetmap/josm/testframework/DataSetTestCaseHelper.java (revision 135) +++ /test/org/openstreetmap/josm/testframework/DataSetTestCaseHelper.java (revision 135) @@ -0,0 +1,71 @@ +package org.openstreetmap.josm.testframework; + +import java.util.Arrays; + +import org.openstreetmap.josm.Main; +import org.openstreetmap.josm.data.coor.LatLon; +import org.openstreetmap.josm.data.osm.DataSet; +import org.openstreetmap.josm.data.osm.Segment; +import org.openstreetmap.josm.data.osm.Node; +import org.openstreetmap.josm.data.osm.Way; +import org.openstreetmap.josm.data.projection.Mercator; + + +/** + * Test cases that need to manupulate a data set can use this helper. + * + * @author Imi + */ +public class DataSetTestCaseHelper { + + /** + * Create a common dataset consisting of: + * - 5 random nodes + * - ls between node 0 and 1 + * - ls between node 1 and 2 + * - ls between node 3 and 4 + * - a way with ls 0 and 1 + */ + public static DataSet createCommon() { + DataSet ds = new DataSet(); + Node n1 = createNode(ds); + Node n2 = createNode(ds); + Node n3 = createNode(ds); + Node n4 = createNode(ds); + Node n5 = createNode(ds); + Segment ls1 = createSegment(ds, n1, n2); + Segment ls2 = createSegment(ds, n2, n3); + createSegment(ds, n4, n5); + createWay(ds, ls1, ls2); + return ds; + } + + public static Way createWay(DataSet ds, Segment... segments) { + Way t = new Way(); + t.segments.addAll(Arrays.asList(segments)); + ds.ways.add(t); + return t; + } + + /** + * Create a segment with out of the given nodes. + */ + public static Segment createSegment(DataSet ds, Node n1, Node n2) { + Segment ls = new Segment(n1, n2); + ds.segments.add(ls); + return ls; + } + + /** + * Add a random node. + */ + public static Node createNode(DataSet ds) { + if (Main.proj == null) + Main.proj = new Mercator(); + Node node = new Node(new LatLon(Math.random(), Math.random())); + if (ds != null) + ds.nodes.add(node); + return node; + } + +} Index: /test/org/openstreetmap/josm/testframework/DateParserTest.java =================================================================== --- /test/org/openstreetmap/josm/testframework/DateParserTest.java (revision 135) +++ /test/org/openstreetmap/josm/testframework/DateParserTest.java (revision 135) @@ -0,0 +1,31 @@ +package org.openstreetmap.josm.testframework; + +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Date; + +import junit.framework.TestCase; + +import org.openstreetmap.josm.tools.DateParser; + +public class DateParserTest extends TestCase { + + public void testWrong() throws Exception { + try { + DateParser.parse("imi"); + assertTrue(false); + } catch (ParseException pe) { + } + } + + public void testRight() throws Exception { + Date d = new SimpleDateFormat("dd MM yyyy HH mm ss SSS Z").parse("23 11 2001 23 05 42 123 +0100"); + Date d2 = new Date(d.getTime()-123); + assertEquals(d2, DateParser.parse("11/23/2001 23:05:42")); + assertEquals(d2, DateParser.parse("11/23/2001T23:05:42")); + assertEquals(d2, DateParser.parse("11/23/2001T23:05:42+001")); + assertEquals(d2, DateParser.parse("2001-11-23T23:05:42+01:00")); + assertEquals(d, DateParser.parse("11/23/2001T23:05:42.123")); + assertEquals(d, DateParser.parse("11/23/2001T23:05:42.123+001")); + } +}