Changeset 15696 in josm for trunk/src

Timestamp:

2020-01-13T00:11:29+01:00 (5 years ago)

Author:

Don-vip

Message:

fix #18020 - don't show way directions for boundary relations

Location:

trunk/src/org/openstreetmap/josm

Files:

• data/validation/tests/PublicTransportRouteTest.java (modified) (1 diff)
• gui/dialogs/relation/MemberTableLinkedCellRenderer.java (modified) (4 diffs)
• gui/dialogs/relation/MemberTableModel.java (modified) (1 diff)
• gui/dialogs/relation/sort/WayConnectionType.java (modified) (5 diffs)
• gui/dialogs/relation/sort/WayConnectionTypeCalculator.java (modified) (8 diffs)

trunk/src/org/openstreetmap/josm/data/validation/tests/PublicTransportRouteTest.java

@@ -61 +61 @@
         }
 
-        final List<WayConnectionType> links = connectionTypeCalculator.updateLinks(membersToCheck);
+        final List<WayConnectionType> links = connectionTypeCalculator.updateLinks(r, membersToCheck);
         for (int i = 0; i < links.size(); i++) {
             final WayConnectionType link = links.get(i);

trunk/src/org/openstreetmap/josm/gui/dialogs/relation/MemberTableLinkedCellRenderer.java

@@ -32 +32 @@
 
         reset();
-        if (value == null)
-            return this;
-
-        this.value = (WayConnectionType) value;
-        setToolTipText(((WayConnectionType) value).getTooltip());
-        renderBackgroundForeground(getModel(table), null, isSelected);
+        if (value != null) {
+            this.value = (WayConnectionType) value;
+            setToolTipText(((WayConnectionType) value).getTooltip());
+            renderBackgroundForeground(getModel(table), null, isSelected);
+        }
         return this;
     }
@@ -63 +62 @@
         int w = 2;
         int p = 2 + w + 1;
+        int y1 = computePreviousY(g, xloop, xowloop, xoff, w, p);
+        int y2 = computeNextY(g, ymax, xloop, xowloop, xoff, w, p);
+
+        /* vertical lines */
+        if (value.onewayFollowsNext && value.onewayFollowsPrevious) {
+            g.setColor(Color.black);
+        } else {
+            g.setColor(Color.lightGray);
+        }
+        if (value.isLoop) {
+            g.drawLine(xoff+xloop, y1, xoff+xloop, y2);
+        }
+
+        if (value.isOnewayHead) {
+            setDotted(g);
+            y1 = 7;
+
+            int[] xValues = {xoff - xowloop + 1, xoff - xowloop + 1, xoff};
+            int[] yValues = {ymax, y1+1, 1};
+            g.drawPolyline(xValues, yValues, 3);
+            unsetDotted(g);
+            g.drawLine(xoff + xowloop, y1+1, xoff, 1);
+        }
+
+        if (value.isOnewayTail) {
+            setDotted(g);
+            y2 = ymax - 7;
+
+            int[] xValues = {xoff+1, xoff - xowloop + 1, xoff - xowloop + 1};
+            int[] yValues = {ymax-1, y2, y1};
+            g.drawPolyline(xValues, yValues, 3);
+            unsetDotted(g);
+            g.drawLine(xoff + xowloop, y2, xoff, ymax-1);
+        }
+
+        if ((value.isOnewayLoopForwardPart || value.isOnewayLoopBackwardPart) && !value.isOnewayTail && !value.isOnewayHead) {
+            setDotted(g);
+            g.drawLine(xoff - xowloop+1, y1, xoff - xowloop+1, y2 + 1);
+            unsetDotted(g);
+        }
+
+        if (!value.isOnewayLoopForwardPart && !value.isOnewayLoopBackwardPart) {
+            g.drawLine(xoff, y1, xoff, y2);
+        }
+
+        g.drawLine(xoff+xowloop, y1, xoff+xowloop, y2);
+
+        /* special icons */
+        Image arrow = getArrow();
+        if (value.direction == Direction.ROUNDABOUT_LEFT) {
+            g.drawImage(ROUNDABOUT_LEFT, xoff-6, 1, null);
+        } else if (value.direction == Direction.ROUNDABOUT_RIGHT) {
+            g.drawImage(ROUNDABOUT_RIGHT, xoff-6, 1, null);
+        }
+
+        if (!value.isOnewayLoopForwardPart && !value.isOnewayLoopBackwardPart &&
+                (arrow != null)) {
+            g.drawImage(arrow, xoff-3, (y1 + y2) / 2 - 2, null);
+        }
+
+        if (value.isOnewayLoopBackwardPart && value.isOnewayLoopForwardPart) {
+            if (arrow == ARROW_DOWN) {
+                arrow = ARROW_UP;
+            } else if (arrow == ARROW_UP) {
+                arrow = ARROW_DOWN;
+            }
+        }
+
+        if (arrow != null) {
+            g.drawImage(arrow, xoff+xowloop-3, (y1 + y2) / 2 - 2, null);
+        }
+    }
+
+    private int computePreviousY(Graphics g, int xloop, int xowloop, int xoff, int w, int p) {
         int y1;
-        int y2;
 
         if (value.linkPrev) {
@@ -95 +167 @@
             }
         }
+        return y1;
+    }
+
+    private int computeNextY(Graphics g, int ymax, int xloop, int xowloop, int xoff, int w, int p) {
+        int y2;
 
         if (value.linkNext) {
@@ -126 +203 @@
             }
         }
-
-        /* vertical lines */
-        if (value.onewayFollowsNext && value.onewayFollowsPrevious) {
-            g.setColor(Color.black);
-        } else {
-            g.setColor(Color.lightGray);
-        }
-        if (value.isLoop) {
-            g.drawLine(xoff+xloop, y1, xoff+xloop, y2);
-        }
-
-        if (value.isOnewayHead) {
-            setDotted(g);
-            y1 = 7;
-
-            int[] xValues = {xoff - xowloop + 1, xoff - xowloop + 1, xoff};
-            int[] yValues = {ymax, y1+1, 1};
-            g.drawPolyline(xValues, yValues, 3);
-            unsetDotted(g);
-            g.drawLine(xoff + xowloop, y1+1, xoff, 1);
-        }
-
-        if (value.isOnewayTail) {
-            setDotted(g);
-            y2 = ymax - 7;
-
-            int[] xValues = {xoff+1, xoff - xowloop + 1, xoff - xowloop + 1};
-            int[] yValues = {ymax-1, y2, y1};
-            g.drawPolyline(xValues, yValues, 3);
-            unsetDotted(g);
-            g.drawLine(xoff + xowloop, y2, xoff, ymax-1);
-        }
-
-        if ((value.isOnewayLoopForwardPart || value.isOnewayLoopBackwardPart) && !value.isOnewayTail && !value.isOnewayHead) {
-            setDotted(g);
-            g.drawLine(xoff - xowloop+1, y1, xoff - xowloop+1, y2 + 1);
-            unsetDotted(g);
-        }
-
-        if (!value.isOnewayLoopForwardPart && !value.isOnewayLoopBackwardPart) {
-            g.drawLine(xoff, y1, xoff, y2);
-        }
-
-        g.drawLine(xoff+xowloop, y1, xoff+xowloop, y2);
-
-        /* special icons */
-        Image arrow;
-        switch (value.direction) {
-        case FORWARD:
-            arrow = ARROW_DOWN;
-            break;
-        case BACKWARD:
-            arrow = ARROW_UP;
-            break;
-        default:
-            arrow = null;
-        }
-        if (value.direction == Direction.ROUNDABOUT_LEFT) {
-            g.drawImage(ROUNDABOUT_LEFT, xoff-6, 1, null);
-        } else if (value.direction == Direction.ROUNDABOUT_RIGHT) {
-            g.drawImage(ROUNDABOUT_RIGHT, xoff-6, 1, null);
-        }
-
-        if (!value.isOnewayLoopForwardPart && !value.isOnewayLoopBackwardPart &&
-                (arrow != null)) {
-            g.drawImage(arrow, xoff-3, (y1 + y2) / 2 - 2, null);
-        }
-
-        if (value.isOnewayLoopBackwardPart && value.isOnewayLoopForwardPart) {
-            if (arrow == ARROW_DOWN) {
-                arrow = ARROW_UP;
-            } else if (arrow == ARROW_UP) {
-                arrow = ARROW_DOWN;
-            }
-        }
-
-        if (arrow != null) {
-            g.drawImage(arrow, xoff+xowloop-3, (y1 + y2) / 2 - 2, null);
-        }
+        return y2;
+    }
+
+    private Image getArrow() {
+        if (!value.ignoreOneway) {
+            switch (value.direction) {
+            case FORWARD:
+                return ARROW_DOWN;
+            case BACKWARD:
+                return ARROW_UP;
+            default:
+                break;
+            }
+        }
+        return null;
     }
 

trunk/src/org/openstreetmap/josm/gui/dialogs/relation/MemberTableModel.java

@@ -777 +777 @@
         try {
             if (connectionType == null) {
-                connectionType = wayConnectionTypeCalculator.updateLinks(members);
+                connectionType = wayConnectionTypeCalculator.updateLinks(relation, members);
             }
             return connectionType.get(i);

trunk/src/org/openstreetmap/josm/gui/dialogs/relation/sort/WayConnectionType.java

@@ -36 +36 @@
         FORWARD, BACKWARD, ROUNDABOUT_LEFT, ROUNDABOUT_RIGHT, NONE;
 
+        /**
+         * Determines if the direction denotes a roundabout.
+         * @return {@code true} if the direction denotes a roundabout
+         */
         public boolean isRoundabout() {
             return this == ROUNDABOUT_RIGHT || this == ROUNDABOUT_LEFT;
@@ -43 +47 @@
     /** True, if the element is part of a closed loop of ways. */
     public boolean isLoop;
+
+    /** True, if all oneway features are ignored */
+    public boolean ignoreOneway;
 
     public boolean isOnewayLoopForwardPart;
@@ -54 +61 @@
     public boolean onewayFollowsNext = true;
 
+    /**
+     * Constructs a valid instance.
+     * @param linkPrev {@code true} if linked to the previous member
+     * @param linkNext {@code true} if linked to the next member
+     * @param direction the direction type
+     */
     public WayConnectionType(boolean linkPrev, boolean linkNext, Direction direction) {
         this.linkPrev = linkPrev;
@@ -62 +75 @@
     }
 
+    /**
+     * Constructs a valid or invalid instance.
+     * @param invalid {@code true} if the instance is invalid (i.e does not concern a complete way)
+     */
     public WayConnectionType(boolean invalid) {
         this.invalid = invalid;
@@ -75 +92 @@
     }
 
+    /**
+     * Determines if the connection type is valid (i.e. it concerns a complete way).
+     * @return {@code true} if the connection type is valid (i.e. it concerns a complete way)
+     */
     public boolean isValid() {
         return !invalid;

trunk/src/org/openstreetmap/josm/gui/dialogs/relation/sort/WayConnectionTypeCalculator.java

@@ -10 +10 @@
 
 import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.Relation;
 import org.openstreetmap.josm.data.osm.RelationMember;
 import org.openstreetmap.josm.data.osm.Way;
@@ -30 +31 @@
      */
     public List<WayConnectionType> updateLinks(List<RelationMember> members) {
+        return updateLinks(null, members);
+    }
+
+    /**
+     * refresh the cache of member WayConnectionTypes
+     * @param r relation. Can be null, for plugins compatibility, but really shouldn't
+     * @param members relation members
+     * @return way connections
+     * @since 15696
+     */
+    public List<WayConnectionType> updateLinks(Relation r, List<RelationMember> members) {
         this.members = members;
         final List<WayConnectionType> con = new ArrayList<>();
@@ -46 +58 @@
         for (int i = 0; i < members.size(); ++i) {
             try {
-                lastWct = updateLinksFor(con, lastWct, i);
+                lastWct = updateLinksFor(r, con, lastWct, i);
             } catch (RuntimeException e) {
                 int index = i;
@@ -58 +70 @@
     }
 
-    private WayConnectionType updateLinksFor(final List<WayConnectionType> con, WayConnectionType lastWct, int i) {
+    private WayConnectionType updateLinksFor(Relation r, List<WayConnectionType> con, WayConnectionType lastWct, int i) {
         final RelationMember m = members.get(i);
         if (isNoHandleableWay(m)) {
@@ -67 +79 @@
             firstGroupIdx = i;
         } else {
-            WayConnectionType wct = computeNextWayConnection(con, lastWct, i, m);
+            WayConnectionType wct = computeNextWayConnection(r, con, lastWct, i, m);
 
             if (!wct.linkPrev) {
@@ -84 +96 @@
     }
 
-    private WayConnectionType computeNextWayConnection(final List<WayConnectionType> con, WayConnectionType lastWct, int i,
+    private WayConnectionType computeNextWayConnection(Relation r, List<WayConnectionType> con, WayConnectionType lastWct, int i,
             final RelationMember m) {
         WayConnectionType wct = new WayConnectionType(false);
         wct.linkPrev = i > 0 && con.get(i-1) != null && con.get(i-1).isValid();
         wct.direction = NONE;
-
-        if (RelationSortUtils.isOneway(m)) {
+        wct.ignoreOneway = isOnewayIgnored(r);
+
+        if (!wct.ignoreOneway && RelationSortUtils.isOneway(m)) {
             handleOneway(lastWct, i, wct);
         }
@@ -121 +134 @@
         }
 
+        if (!wct.ignoreOneway) {
+            handleOnewayFollows(lastWct, i, m, wct);
+        }
+        con.set(i, wct);
+        return wct;
+    }
+
+    private static boolean isOnewayIgnored(Relation r) {
+        return r != null && "boundary".equals(r.get("type"));
+    }
+
+    protected void handleOnewayFollows(WayConnectionType lastWct, int i, final RelationMember m,
+            WayConnectionType wct) {
         if (lastWct != null && i > 0 && m.getMember() instanceof Way && members.get(i - 1).getMember() instanceof Way
                 && (m.getWay().isOneway() != 0 || members.get(i - 1).getWay().isOneway() != 0)) {
@@ -135 +161 @@
             }
         }
-        con.set(i, wct);
-        return wct;
     }