Changeset 11147 in josm for trunk/src/org/openstreetmap/josm/gui/draw

Timestamp:

2016-10-19T15:28:45+02:00 (8 years ago)

Author:

michael2402

Message:

Fix 13636: Use line clipping for computing the one way arrows, too.

File:

• trunk/src/org/openstreetmap/josm/gui/draw/MapViewPath.java (modified) (6 diffs)

trunk/src/org/openstreetmap/josm/gui/draw/MapViewPath.java

@@ -178 +178 @@
      * @param stroke The stroke to compute the line for.
      * @return The new line shape.
+     * @since 11147
      */
     public Shape computeClippedLine(Stroke stroke) {
+        MapPath2D clamped = new MapPath2D();
+        if (visitClippedLine(stroke, (inLineOffset, start, end, startIsOldEnd) -> {
+            if (!startIsOldEnd) {
+                clamped.moveTo(start);
+            }
+            clamped.lineTo(end);
+        })) {
+            return clamped;
+        } else {
+            // could not clip the path.
+            return this;
+        }
+    }
+
+    /**
+     * Visits all straight segments of this path. The segments are clamped to the view.
+     * If they are clamped, the start points are aligned with the pattern.
+     * @param stroke The stroke to take the dash information from.
+     * @param consumer The consumer to call for each segment
+     * @return false if visiting the path failed because there e.g. were non-straight segments.
+     * @since 11147
+     */
+    public boolean visitClippedLine(Stroke stroke, PathSegmentConsumer consumer) {
         if (stroke instanceof BasicStroke && ((BasicStroke) stroke).getDashArray() != null) {
             float length = 0;
@@ -185 +209 @@
                 length += f;
             }
-            return computeClippedLine(((BasicStroke) stroke).getDashPhase(), length);
+            return visitClippedLine(((BasicStroke) stroke).getDashPhase(), length, consumer);
         } else {
-            return computeClippedLine(0, 0);
-        }
-    }
-
-    private Shape computeClippedLine(double strokeOffset, double strokeLength) {
-        ClampingPathVisitor path = new ClampingPathVisitor(state.getViewClipRectangle(), strokeOffset, strokeLength);
-        if (path.visit(getPathIterator(null))) {
-            return path;
-        } else {
-            // could not clip the path.
-            return this;
-        }
-    }
-
-    private class ClampingPathVisitor extends MapPath2D {
+            return visitClippedLine(0, 0, consumer);
+        }
+    }
+
+    /**
+     * Visits all straight segments of this path. The segments are clamped to the view.
+     * If they are clamped, the start points are aligned with the pattern.
+     * @param strokeOffset The initial offset of the pattern
+     * @param strokeLength The dash pattern length. 0 to use no pattern.
+     * @param consumer The consumer to call for each segment
+     * @return false if visiting the path failed because there e.g. were non-straight segments.
+     * @since 11147
+     */
+    public boolean visitClippedLine(double strokeOffset, double strokeLength, PathSegmentConsumer consumer) {
+        return new ClampingPathVisitor(state.getViewClipRectangle(), strokeOffset, strokeLength, consumer)
+            .visit(this);
+    }
+
+
+    /**
+     * This class is used to visit the segments of this path.
+     * @author Michael Zangl
+     * @since 11147
+     */
+    public interface PathSegmentConsumer {
+
+        /**
+         * Add a line segment between two points
+         * @param inLineOffset The offset of start in the line
+         * @param start The start point
+         * @param end The end point
+         * @param startIsOldEnd If the start point equals the last end point.
+         */
+        void addLineBetween(double inLineOffset, MapViewPoint start, MapViewPoint end, boolean startIsOldEnd);
+
+    }
+
+    private class ClampingPathVisitor {
         private final MapViewRectangle clip;
-        private double strokeProgress;
+        private final PathSegmentConsumer consumer;
+        protected double strokeProgress;
         private final double strokeLength;
         private MapViewPoint lastMoveTo;
@@ -210 +258 @@
         private boolean cursorIsActive = false;
 
-        ClampingPathVisitor(MapViewRectangle clip, double strokeOffset, double strokeLength) {
+        /**
+         * Create a new {@link ClampingPathVisitor}
+         * @param clip View clip rectangle
+         * @param strokeOffset Initial stroke offset
+         * @param strokeLength Total length of a stroke sequence
+         * @param consumer The consumer to notify of the path segments.
+         */
+        ClampingPathVisitor(MapViewRectangle clip, double strokeOffset, double strokeLength, PathSegmentConsumer consumer) {
             this.clip = clip;
             this.strokeProgress = Math.min(strokeLength - strokeOffset, 0);
             this.strokeLength = strokeLength;
+            this.consumer = consumer;
         }
 
         /**
          * Append a path to this one. The path is clipped to the current view.
-         * @param it The iterator
+         * @param mapViewPath The iterator
          * @return true if adding the path was successful.
          */
-        public boolean visit(PathIterator it) {
+        public boolean visit(MapViewPath mapViewPath) {
             double[] coords = new double[8];
+            PathIterator it = mapViewPath.getPathIterator(null);
             while (!it.isDone()) {
                 int type = it.currentSegment(coords);
@@ -252 +309 @@
             lastMoveTo = point;
             cursor = point;
+            cursorIsActive = false;
         }
 
@@ -264 +322 @@
                 if (!cursorIsActive || !entry.equals(cursor)) {
                     entry = alignStrokeOffset(entry, cursor);
-                    moveTo(entry);
                 }
-                lineTo(exit);
+                consumer.addLineBetween(strokeProgress + cursor.distanceToInView(entry), entry, exit, cursorIsActive);
                 cursorIsActive = exit.equals(next);
             }
@@ -273 +330 @@
             cursor = next;
         }
+
 
         private MapViewPoint alignStrokeOffset(MapViewPoint entry, MapViewPoint originalStart) {