Changeset 203 in josm


Ignore:
Timestamp:
2007-02-17T17:09:49+01:00 (17 years ago)
Author:
imi
Message:
  • Fixed a bug in the Merger/Conflict to auto-resolve marked changes without real changes
  • Fixed bug in split way, that reversed the order of segments in one way.
  • Fixed bug where dialogs did not update anymore after loading a dataset twice
Files:
2 deleted
21 edited

Legend:

Unmodified
Added
Removed

  • src/org/openstreetmap/josm/Main.java

    r192 r203  
    160160        public final void removeLayer(final Layer layer) {
    161161                map.mapView.removeLayer(layer);
    162                 if (layer instanceof OsmDataLayer)
    163                         ds = new DataSet();
     162                if (layer instanceof OsmDataLayer) {
     163                        DataSet newDs = new DataSet();
     164                        newDs.listeners.addAll(ds.listeners);
     165                        ds = newDs;
     166                }
    164167                if (map.mapView.getAllLayers().isEmpty())
    165168                        setMapFrame(null);

  • src/org/openstreetmap/josm/actions/AutoScaleAction.java

    r155 r203  
    6060                setCurrent(0);
    6161                this.mapFrame = mapFrame;
    62                 Main.ds.addSelectionChangedListener(new SelectionChangedListener(){
     62                Main.ds.listeners.add(new SelectionChangedListener(){
    6363                        public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
    6464                                if (mode.equals("selection"))

  • src/org/openstreetmap/josm/actions/SplitWayAction.java

    r194 r203  
    9898        public SplitWayAction() {
    9999                super(tr("Split Way"), "splitway", tr("Split a way at the selected node."), KeyEvent.VK_P, KeyEvent.CTRL_MASK | KeyEvent.SHIFT_MASK, true);
    100                 Main.ds.addSelectionChangedListener(this);
     100                Main.ds.listeners.add(this);
    101101        }
    102102
    … …  
    230230
    231231                // finally check if the selected way is complete.
    232                 for (Segment s : selectedWay.segments) {
    233                         if (s.incomplete) {
    234                                 JOptionPane.showMessageDialog(Main.parent, tr("Warning: This way is incomplete. Try to download it before splitting."));
    235                                 return;
    236                         }
     232                if (selectedWay.isIncomplete()) {
     233                        JOptionPane.showMessageDialog(Main.parent, tr("Warning: This way is incomplete. Try to download it before splitting."));
     234                        return;
    237235                }
    238236
    … …  
    311309                                // the moveSegments method.
    312310                                if (split) {
    313                                         ArrayList<Segment> subSegments = new ArrayList<Segment>();
     311                                        LinkedList<Segment> subSegments = new LinkedList<Segment>();
    314312                                        moveSegments(allSegments, subSegments, splitSeg, selectedNodes);
    315313                                        segmentSets.add(subSegments);
    … …  
    356354                        partThatContainsSegments.removeAll(selectedSegments);
    357355                        if (!partThatContainsSegments.isEmpty()) {
    358                                 ArrayList<Segment> contiguousSubpart = new ArrayList<Segment>();
     356                                LinkedList<Segment> contiguousSubpart = new LinkedList<Segment>();
    359357                                moveSegments(partThatContainsSegments, contiguousSubpart, partThatContainsSegments.get(0), null);
    360358                                // if partThatContainsSegments was contiguous before, it will now be empty as all segments
    … …  
    380378
    381379                        while (!allSegments.isEmpty()) {
    382                                 List<Segment> subSegments = new LinkedList<Segment>();
     380                                LinkedList<Segment> subSegments = new LinkedList<Segment>();
    383381                                moveSegments(allSegments, subSegments, allSegments.get(0), null);
    384382                                segmentSets.add(subSegments);
    … …  
    465463         * @param stopNodes collection of nodes which should be considered end points for moving (may be null).
    466464         */
    467         private void moveSegments(Collection<Segment> source, Collection<Segment> destination, Segment start, Collection<Node> stopNodes) {
     465        private void moveSegments(Collection<Segment> source, LinkedList<Segment> destination, Segment start, Collection<Node> stopNodes) {
    468466                source.remove(start);
    469                 destination.add(start);
     467                if (destination.isEmpty() || destination.iterator().next().from.equals(start.to))
     468                        destination.addFirst(start);
     469                else
     470                        destination.addLast(start);
    470471                Segment moveSeg = start;
    471472                while(moveSeg != null) {
    … …  
    473474
    474475                        for (Node node : new Node[] { start.from, start.to }) {
    475                                 if (stopNodes != null && stopNodes.contains(node)) continue;
     476                                if (stopNodes != null && stopNodes.contains(node))
     477                                        continue;
    476478                                for (Segment sourceSeg : source) {
    477479                                        if (sourceSeg.from.equals(node) || sourceSeg.to.equals(node)) {

  • src/org/openstreetmap/josm/actions/mapmode/AddWayAction.java

    r184 r203  
    6060        public AddWayAction(MapFrame mapFrame) {
    6161                super(tr("Add Way"), "addway", tr("Add a new way to the data."), KeyEvent.VK_W, mapFrame, ImageProvider.getCursor("normal", "way"));
    62                
    63                 Main.ds.addSelectionChangedListener(this);
     62                Main.ds.listeners.add(this);
    6463        }
    6564

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

    r175 r203  
    55import java.util.Collections;
    66import java.util.HashSet;
    7 import java.util.Iterator;
    87import java.util.LinkedList;
    98import java.util.List;
    … …  
    4746         * A list of listeners to selection changed events.
    4847         */
    49         transient Collection<SelectionChangedListener> listeners = new LinkedList<SelectionChangedListener>();
     48        transient public Collection<SelectionChangedListener> listeners = new LinkedList<SelectionChangedListener>();
    5049
    5150        /**
    … …  
    143142                        l.selectionChanged(sel);
    144143        }
    145 
    146         /**
    147          * Add a listener to the selection changed listener list. If <code>null</code>
    148          * is passed, nothing happens.
    149          * @param listener The listener to add to the list.
    150          */
    151         public void addSelectionChangedListener(SelectionChangedListener listener) {
    152                 if (listener != null)
    153                         listeners.add(listener);
    154         }
    155 
    156         /**
    157          * Remove a listener from the selection changed listener list.
    158          * If <code>null</code> is passed, nothing happens.
    159          * @param listener The listener to remove from the list.
    160          */
    161         public void removeSelectionChangedListener(SelectionChangedListener listener) {
    162                 if (listener != null)
    163                         listeners.remove(listener);
    164         }
    165 
    166         public void addAllSelectionListener(DataSet ds) {
    167                 listeners.addAll(ds.listeners);
    168         }
    169 
    170         /**
    171          * Compares this and the parameter dataset and return <code>true</code> if both
    172          * contain the same data primitives (ignoring the selection)
    173          */
    174         public boolean realEqual(Collection<OsmPrimitive> other) {
    175                 Collection<OsmPrimitive> my = allPrimitives();
    176 
    177                 if (my.size() != other.size())
    178                         return false;
    179 
    180                 Iterator<OsmPrimitive> it = other.iterator();
    181                 for (OsmPrimitive osm : my)
    182                         if (!osm.realEqual(it.next()))
    183                                 return false;
    184 
    185                 return true;
    186         }
    187144}

  • src/org/openstreetmap/josm/data/osm/Node.java

    r100 r203  
    4343        }
    4444
    45         @Override public boolean realEqual(OsmPrimitive osm) {
    46                 return osm instanceof Node ? super.realEqual(osm) && coor.equals(((Node)osm).coor) : false;
     45        @Override public boolean realEqual(OsmPrimitive osm, boolean semanticOnly) {
     46                return osm instanceof Node ? super.realEqual(osm, semanticOnly) && coor.equals(((Node)osm).coor) : false;
    4747    }
    4848

  • src/org/openstreetmap/josm/data/osm/OsmPrimitive.java

    r194 r203  
    166166        /**
    167167         * Perform an equality compare for all non-volatile fields not only for the id
    168          * but for the whole object (for conflict resolving etc)
     168         * but for the whole object (for conflict resolving)
     169         * @param semanticOnly if <code>true</code>, modified flag and timestamp are not compared
    169170         */
    170         public boolean realEqual(OsmPrimitive osm) {
     171        public boolean realEqual(OsmPrimitive osm, boolean semanticOnly) {
    171172                return
    172                 id == osm.id &&
    173                 modified == osm.modified &&
    174                 deleted == osm.deleted &&
    175                 (timestamp == null ? osm.timestamp==null : timestamp.equals(osm.timestamp)) &&
    176                 (keys == null ? osm.keys==null : keys.equals(osm.keys));
     173                        id == osm.id &&
     174                        (semanticOnly || (modified == osm.modified)) &&
     175                        deleted == osm.deleted &&
     176                        (semanticOnly || (timestamp == null ? osm.timestamp==null : timestamp.equals(osm.timestamp))) &&
     177                        (keys == null ? osm.keys==null : keys.equals(osm.keys));
    177178        }
    178179       

  • src/org/openstreetmap/josm/data/osm/Segment.java

    r187 r203  
    7979        }
    8080
    81         @Override public boolean realEqual(OsmPrimitive osm) {
     81        @Override public boolean realEqual(OsmPrimitive osm, boolean semanticOnly) {
    8282                if (!(osm instanceof Segment))
    83                         return super.realEqual(osm);
     83                        return super.realEqual(osm, semanticOnly);
    8484                if (incomplete)
    8585                        return ((Segment)osm).incomplete;
    86                 return super.realEqual(osm) && from.equals(((Segment)osm).from) && to.equals(((Segment)osm).to);
     86                return super.realEqual(osm, semanticOnly) && from.equals(((Segment)osm).from) && to.equals(((Segment)osm).to);
    8787        }
    8888

  • src/org/openstreetmap/josm/data/osm/Way.java

    r104 r203  
    4343    }
    4444
    45         @Override public boolean realEqual(OsmPrimitive osm) {
    46                 return osm instanceof Way ? super.realEqual(osm) && segments.equals(((Way)osm).segments) : false;
     45        @Override public boolean realEqual(OsmPrimitive osm, boolean semanticOnly) {
     46                return osm instanceof Way ? super.realEqual(osm, semanticOnly) && segments.equals(((Way)osm).segments) : false;
    4747    }
    4848

  • src/org/openstreetmap/josm/data/osm/visitor/MergeVisitor.java

    r197 r203  
    295295
    296296        /**
    297          * @return <code>true</code>, if no merge is needed.
     297         * @return <code>true</code>, if no merge is needed or merge is performed already.
    298298         */
    299299        private <P extends OsmPrimitive> boolean mergeAfterId(Map<P,P> merged, Collection<P> primitives, P other) {
    300300                for (P my : primitives) {
    301                         if (my.realEqual(other))
     301                        Date d1 = my.timestamp == null ? new Date(0) : my.timestamp;
     302                        Date d2 = other.timestamp == null ? new Date(0) : other.timestamp;
     303                        if (my.realEqual(other, false))
    302304                                return true; // no merge needed.
     305                        if (my.realEqual(other, true)) {
     306                                // they differ in modified/timestamp combination only. Auto-resolve it.
     307                                if (merged != null)
     308                                        merged.put(other, my);
     309                                if (d1.before(d2)) {
     310                                        my.modified = other.modified;
     311                                        my.timestamp = other.timestamp;
     312                                }
     313                                return true; // merge done.
     314                        }
    303315                        if (my.id == other.id && my.id != 0) {
    304316                                if (my instanceof Segment && ((Segment)my).incomplete)
    305317                                        return false; // merge always over an incomplete
    306                                 Date d1 = my.timestamp == null ? new Date(0) : my.timestamp;
    307                                 Date d2 = other.timestamp == null ? new Date(0) : other.timestamp;
    308318                                if (my.modified && other.modified) {
    309319                                        conflicts.put(my, other);

  • src/org/openstreetmap/josm/gui/MapView.java

    r198 r203  
    8989
    9090                // listend to selection changes to redraw the map
    91                 Main.ds.addSelectionChangedListener(new SelectionChangedListener(){
     91                Main.ds.listeners.add(new SelectionChangedListener(){
    9292                        public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
    9393                                repaint();
    … …  
    119119                        }
    120120                        editLayer = dataLayer;
    121                         dataLayer.data.addAllSelectionListener(Main.ds);
     121                        dataLayer.data.listeners.addAll(Main.ds.listeners);
    122122                        Main.ds = dataLayer.data;
    123123                        dataLayer.listenerModified.add(new ModifiedChangedListener(){

  • src/org/openstreetmap/josm/gui/dialogs/ConflictDialog.java

    r155 r203  
    8686                add(buttonPanel, BorderLayout.SOUTH);
    8787
    88                 Main.ds.addSelectionChangedListener(new SelectionChangedListener(){
     88                Main.ds.listeners.add(new SelectionChangedListener(){
    8989                        public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
    9090                                displaylist.clearSelection();

  • src/org/openstreetmap/josm/gui/dialogs/HistoryDialog.java

    r155 r203  
    143143        @Override public void setVisible(boolean b) {
    144144                if (b) {
    145                         Main.ds.addSelectionChangedListener(this);
     145                        Main.ds.listeners.add(this);
    146146                        selectionChanged(Main.ds.getSelected());
    147147                } else {
    148                         Main.ds.removeSelectionChangedListener(this);
     148                        Main.ds.listeners.remove(this);
    149149                }
    150150                super.setVisible(b);

  • src/org/openstreetmap/josm/gui/dialogs/PropertiesDialog.java

    r198 r203  
    328328        @Override public void setVisible(boolean b) {
    329329                if (b) {
    330                         Main.ds.addSelectionChangedListener(this);
     330                        Main.ds.listeners.add(this);
    331331                        selectionChanged(Main.ds.getSelected());
    332332                } else {
    333                         Main.ds.removeSelectionChangedListener(this);
     333                        Main.ds.listeners.remove(this);
    334334                }
    335335                super.setVisible(b);

  • src/org/openstreetmap/josm/gui/dialogs/SelectionListDialog.java

    r191 r203  
    8989        @Override public void setVisible(boolean b) {
    9090                if (b) {
    91                         Main.ds.addSelectionChangedListener(this);
     91                        Main.ds.listeners.add(this);
    9292                        selectionChanged(Main.ds.getSelected());
    9393                } else {
    94                         Main.ds.removeSelectionChangedListener(this);
     94                        Main.ds.listeners.remove(this);
    9595                }
    9696                super.setVisible(b);

  • src/org/openstreetmap/josm/io/OsmServerWriter.java

    r179 r203  
    7474                        }
    7575                } catch (RuntimeException e) {
     76                        e.printStackTrace();
    7677                        throw new SAXException("An error occoured: "+e.getMessage());
    7778                }

  • test/org/openstreetmap/josm/data/osm/DataSetTest.java

    r146 r203  
    7777        public void testFireSelectionChanged() {
    7878                TestSelectionChangeListener l = new TestSelectionChangeListener();
    79                 ds.addSelectionChangedListener(l);
     79                ds.listeners.add(l);
    8080                ds.setSelected(segment);
    8181                assertNotNull(l.called);
    … …  
    8484        }
    8585
    86         public void testAddRemoveSelectionChangedListener() {
    87                 TestSelectionChangeListener l = new TestSelectionChangeListener();
    88                 ds.addSelectionChangedListener(l);
    89                 ds.removeSelectionChangedListener(l);
    90                 ds.setSelected(way);
    91                 assertNull(l.called);
    92         }
    93 
    9486        public void testAddAllSelectionListener() {
    9587                DataSet ds2 = new DataSet();
    9688                TestSelectionChangeListener l1 = new TestSelectionChangeListener();
    9789                TestSelectionChangeListener l2 = new TestSelectionChangeListener();
    98                 ds2.addSelectionChangedListener(l1);
    99                 ds2.addSelectionChangedListener(l2);
    100                 ds.addAllSelectionListener(ds2);
    101                 ds2.removeSelectionChangedListener(l1);
     90                ds2.listeners.add(l1);
     91                ds2.listeners.add(l2);
     92                ds.listeners.addAll(ds2.listeners);
     93                ds2.listeners.remove(l1);
    10294                ds.setSelected(node2);
    10395                assertNotNull(l1.called);
    10496                assertNotNull(l2.called);
    10597        }
    106 
    107         public void testRealEqual() {
    108                 Collection<OsmPrimitive> all = new LinkedList<OsmPrimitive>();
    109                 all.add(new Node(node1));
    110                 all.add(new Node(node2));
    111                 all.add(new Node(node3));
    112                 all.add(createSegment(segment.id, node1, node2));
    113                 all.add(createWay(way.id, way.segments.iterator().next()));
    114                 assertTrue(ds.realEqual(all));
    115         }
    11698}

  • test/org/openstreetmap/josm/data/osm/NodeTest.java

    r146 r203  
    2121        public void testCloneFromRealEqual() {
    2222                Node node2 = createNode(23,3,4);
    23                 assertFalse(node2.realEqual(node));
    24                 assertFalse(node.realEqual(node2));
     23                assertFalse(node2.realEqual(node, false));
     24                assertFalse(node.realEqual(node2, false));
    2525                node.cloneFrom(node2);
    26                 assertTrue(node2.realEqual(node));
    27                 assertTrue(node.realEqual(node2));
     26                assertTrue(node2.realEqual(node, false));
     27                assertTrue(node.realEqual(node2, false));
    2828        }
    2929
    3030        public void testNodeNode() {
    3131                Node node2 = new Node(node);
    32                 assertTrue(node2.realEqual(node));
     32                assertTrue(node2.realEqual(node, false));
    3333        }
    3434

  • test/org/openstreetmap/josm/data/osm/SegmentTest.java

    r146 r203  
    2121                Segment s2 = createSegment(23, createNode(1,2,3), createNode(2,3,4));
    2222                segment.cloneFrom(s2);
    23                 assertTrue(segment.realEqual(s2));
    24                 assertTrue(s2.realEqual(segment));
     23                assertTrue(segment.realEqual(s2, false));
     24                assertTrue(s2.realEqual(segment, false));
    2525                assertSame(segment.from, s2.from);
    2626                assertSame(segment.to, s2.to);
    … …  
    2929        public void testSegmentSegment() {
    3030                Segment s = new Segment(segment);
    31                 assertTrue(s.realEqual(segment));
     31                assertTrue(s.realEqual(segment, false));
    3232        }
    3333

  • test/org/openstreetmap/josm/data/osm/WayTest.java

    r146 r203  
    2121                Way w2 = createWay(42);
    2222                way.cloneFrom(w2);
    23                 assertTrue(way.realEqual(w2));
     23                assertTrue(way.realEqual(w2, false));
    2424                assertEquals(w2.segments.size(), way.segments.size());
    2525        }
    … …  
    2828                Way w = new Way(way);
    2929                assertEquals(way.id, w.id);
    30                 assertTrue(way.realEqual(w));
     30                assertTrue(way.realEqual(w, false));
    3131        }
    3232

  • test/org/openstreetmap/josm/data/osm/visitor/MergeVisitorTest.java

    r198 r203  
    197197                s2.timestamp = new Date();
    198198                v.visit(s2);
    199                 assertTrue(s1.realEqual(s2));
     199                assertTrue(s1.realEqual(s2, false));
    200200        }
    201201        /**
    … …  
    312312                assertEquals(1, ds.segments.size());
    313313    }
    314        
     314
     315        /**
     316         * The merger should auto-resolve items, that have not changed but are marked as
     317         * changed. In the case where an unmodified newer item is merged over an modified
     318         * older, the modified-flag should be removed and the newer timestamp is used.
     319         */
     320        public void testMergeModifiedWithOlderTimestampOverUnmodifiedNewerDoesNotConflict() throws Exception {
     321                DataSet ds = new DataSet();
     322
     323                Node oldNode = createNodes(ds, 1)[0];
     324                oldNode.modified = true;
     325                oldNode.timestamp = new Date();
     326               
     327                Node newNode = new Node(oldNode);
     328                Date date = new Date(oldNode.timestamp.getTime()+10000);
     329                newNode.modified = false;
     330                newNode.timestamp = new Date(date.getTime());
     331               
     332                MergeVisitor v = new MergeVisitor(ds);
     333                v.visit(newNode);
     334
     335                assertEquals(0, v.conflicts.size());
     336                assertEquals(date, ds.nodes.iterator().next().timestamp);
     337                assertFalse(ds.nodes.iterator().next().modified);
     338        }
    315339}
Note: See TracChangeset for help on using the changeset viewer.