Ignore:
Timestamp:
2016-08-22T21:16:36+02:00 (3 years ago)
Author:
Don-vip
Message:

fix #13413 - Clean ImproveWayAccuracyAction, add new class MapViewPath (patch by michael2402, modified) - gsoc-core

Location:
trunk/src/org/openstreetmap/josm/actions/mapmode
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/actions/mapmode/DrawAction.java

    r10874 r10875  
    5252import org.openstreetmap.josm.data.osm.WaySegment;
    5353import org.openstreetmap.josm.data.osm.visitor.paint.ArrowPaintHelper;
    54 import org.openstreetmap.josm.data.osm.visitor.paint.MapPath2D;
    5554import org.openstreetmap.josm.data.osm.visitor.paint.PaintColors;
    5655import org.openstreetmap.josm.data.preferences.AbstractToStringProperty;
     
    6665import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
    6766import org.openstreetmap.josm.gui.NavigatableComponent;
     67import org.openstreetmap.josm.gui.draw.MapPath2D;
     68import org.openstreetmap.josm.gui.draw.MapViewPath;
     69import org.openstreetmap.josm.gui.draw.SymbolShape;
    6870import org.openstreetmap.josm.gui.layer.Layer;
    6971import org.openstreetmap.josm.gui.layer.MapViewPaintable;
     
    15091511                g2.setStroke(HELPER_STROKE.get());
    15101512
    1511                 MapPath2D b = new MapPath2D();
     1513                MapViewPath b = new MapViewPath(mv);
    15121514                b.moveTo(p2);
    15131515                if (absoluteFix) {
     
    15211523                g2.setColor(SNAP_HELPER_COLOR.get());
    15221524                g2.setStroke(HELPER_STROKE.get());
    1523                 MapPath2D b = new MapPath2D();
     1525                MapViewPath b = new MapViewPath(mv);
    15241526                b.moveTo(p3);
    1525                 b.lineTo(mv.getPointFor(projectionSource));
     1527                b.lineTo(projectionSource);
    15261528                g2.draw(b);
    15271529            }
     
    15301532                g2.setColor(HIGHLIGHT_COLOR.get());
    15311533                g2.setStroke(HIGHLIGHT_STROKE.get());
    1532                 MapPath2D b = new MapPath2D();
    1533                 b.moveTo(mv.getPointFor(segmentPoint1));
    1534                 b.lineTo(mv.getPointFor(segmentPoint2));
     1534                MapViewPath b = new MapViewPath(mv);
     1535                b.moveTo(segmentPoint1);
     1536                b.lineTo(segmentPoint2);
    15351537                g2.draw(b);
    15361538            }
     
    15381540            g2.setColor(RUBBER_LINE_COLOR.get());
    15391541            g2.setStroke(RUBBER_LINE_STROKE.get());
    1540             MapPath2D b = new MapPath2D();
     1542            MapViewPath b = new MapViewPath(mv);
    15411543            b.moveTo(p1);
    15421544            b.lineTo(p3);
     
    15461548            if (SHOW_PROJECTED_POINT.get()) {
    15471549                g2.setStroke(RUBBER_LINE_STROKE.get());
    1548                 g2.drawOval((int) p3.getInViewX()-5, (int) p3.getInViewY()-5, 10, 10); // projected point
     1550                g2.draw(new MapViewPath(mv).shapeAround(p3, SymbolShape.CIRCLE, 10)); // projected point
    15491551            }
    15501552
     
    15541556
    15551557        /**
    1556          *  If mouse position is close to line at 15-30-45-... angle, remembers this direction
     1558         * If mouse position is close to line at 15-30-45-... angle, remembers this direction
    15571559         * @param currentEN Current position
    15581560         * @param baseHeading The heading
  • trunk/src/org/openstreetmap/josm/actions/mapmode/ExtrudeAction.java

    r10853 r10875  
    4848import org.openstreetmap.josm.gui.MapFrame;
    4949import org.openstreetmap.josm.gui.MapView;
     50import org.openstreetmap.josm.gui.draw.MapViewPath;
     51import org.openstreetmap.josm.gui.draw.SymbolShape;
    5052import org.openstreetmap.josm.gui.layer.Layer;
    5153import org.openstreetmap.josm.gui.layer.MapViewPaintable;
     
    10191021            if (newN1en != null) {
    10201022
    1021                 Point p1 = mv.getPoint(initialN1en);
    1022                 Point p2 = mv.getPoint(initialN2en);
    1023                 Point p3 = mv.getPoint(newN1en);
    1024                 Point p4 = mv.getPoint(newN2en);
     1023                EastNorth p1 = initialN1en;
     1024                EastNorth p2 = initialN2en;
     1025                EastNorth p3 = newN1en;
     1026                EastNorth p4 = newN2en;
    10251027
    10261028                Point2D normalUnitVector = activeMoveDirection != null ? getNormalUniVector() : null;
     
    10301032                    g2.setStroke(mainStroke);
    10311033                    // Draw rectangle around new area.
    1032                     GeneralPath b = new GeneralPath();
    1033                     b.moveTo(p1.x, p1.y);
    1034                     b.lineTo(p3.x, p3.y);
    1035                     b.lineTo(p4.x, p4.y);
    1036                     b.lineTo(p2.x, p2.y);
    1037                     b.lineTo(p1.x, p1.y);
     1034                    MapViewPath b = new MapViewPath(mv);
     1035                    b.moveTo(p1);
     1036                    b.lineTo(p3);
     1037                    b.lineTo(p4);
     1038                    b.lineTo(p2);
     1039                    b.lineTo(p1);
    10381040                    g2.draw(b);
    10391041
     
    10631065                    if (p1.distance(p2) < 3) {
    10641066                        g2.setStroke(mainStroke);
    1065                         g2.drawOval((int) (p1.x-symbolSize/2), (int) (p1.y-symbolSize/2),
    1066                                 (int) (symbolSize), (int) (symbolSize));
     1067                        g2.draw(new MapViewPath(mv).shapeAround(p1, SymbolShape.CIRCLE, symbolSize));
    10671068                    } else {
    1068                         Line2D oldline = new Line2D.Double(p1, p2);
    10691069                        g2.setStroke(oldLineStroke);
    1070                         g2.draw(oldline);
     1070                        g2.draw(new MapViewPath(mv).moveTo(p1).lineTo(p2));
    10711071                    }
    10721072
     
    10811081                        // Draw a guideline along the normal.
    10821082                        Line2D normline;
    1083                         Point2D centerpoint = new Point2D.Double((p1.getX()+p2.getX())*0.5, (p1.getY()+p2.getY())*0.5);
     1083                        Point2D centerpoint = mv.getPoint2D(p1.interpolate(p2, .5));
    10841084                        normline = createSemiInfiniteLine(centerpoint, normalUnitVector, g2);
    10851085                        g2.draw(normline);
     
    11631163     */
    11641164    private void drawReferenceSegment(Graphics2D g2, MapView mv, ReferenceSegment seg) {
    1165         Point p1 = mv.getPoint(seg.p1);
    1166         Point p2 = mv.getPoint(seg.p2);
    1167         GeneralPath b = new GeneralPath();
    1168         b.moveTo(p1.x, p1.y);
    1169         b.lineTo(p2.x, p2.y);
    11701165        g2.setColor(helperColor);
    11711166        g2.setStroke(helperStrokeDash);
    1172         g2.draw(b);
     1167        g2.draw(new MapViewPath(mv).moveTo(seg.p1).lineTo(seg.p2));
    11731168    }
    11741169
  • trunk/src/org/openstreetmap/josm/actions/mapmode/ImproveWayAccuracyAction.java

    r10853 r10875  
    66import static org.openstreetmap.josm.tools.I18n.trn;
    77
     8import java.awt.BasicStroke;
    89import java.awt.Color;
    910import java.awt.Cursor;
    1011import java.awt.Graphics2D;
    1112import java.awt.Point;
    12 import java.awt.Stroke;
    1313import java.awt.event.KeyEvent;
    1414import java.awt.event.MouseEvent;
     
    3535import org.openstreetmap.josm.data.osm.Way;
    3636import org.openstreetmap.josm.data.osm.WaySegment;
    37 import org.openstreetmap.josm.data.osm.visitor.paint.MapPath2D;
    3837import org.openstreetmap.josm.data.osm.visitor.paint.PaintColors;
     38import org.openstreetmap.josm.data.preferences.CachingProperty;
    3939import org.openstreetmap.josm.data.preferences.ColorProperty;
     40import org.openstreetmap.josm.data.preferences.IntegerProperty;
     41import org.openstreetmap.josm.data.preferences.StrokeProperty;
    4042import org.openstreetmap.josm.gui.MapFrame;
    4143import org.openstreetmap.josm.gui.MapView;
    42 import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
     44import org.openstreetmap.josm.gui.draw.MapViewPath;
     45import org.openstreetmap.josm.gui.draw.SymbolShape;
    4346import org.openstreetmap.josm.gui.layer.AbstractMapViewPaintable;
    4447import org.openstreetmap.josm.gui.layer.Layer;
    4548import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    46 import org.openstreetmap.josm.gui.util.GuiHelper;
    4749import org.openstreetmap.josm.gui.util.ModifierListener;
    4850import org.openstreetmap.josm.tools.ImageProvider;
     
    5658        SelectionChangedListener, ModifierListener {
    5759
    58     enum State {
    59         selecting, improving
     60    private enum State {
     61        SELECTING, IMPROVING
    6062    }
    6163
     
    7375    private boolean dragging;
    7476
    75     private final Cursor cursorSelect;
    76     private final Cursor cursorSelectHover;
    77     private final Cursor cursorImprove;
    78     private final Cursor cursorImproveAdd;
    79     private final Cursor cursorImproveDelete;
    80     private final Cursor cursorImproveAddLock;
    81     private final Cursor cursorImproveLock;
     77    private final Cursor cursorSelect = ImageProvider.getCursor("normal", "mode");
     78    private final Cursor cursorSelectHover = ImageProvider.getCursor("hand", "mode");
     79    private final Cursor cursorImprove = ImageProvider.getCursor("crosshair", null);
     80    private final Cursor cursorImproveAdd = ImageProvider.getCursor("crosshair", "addnode");
     81    private final Cursor cursorImproveDelete = ImageProvider.getCursor("crosshair", "delete_node");
     82    private final Cursor cursorImproveAddLock = ImageProvider.getCursor("crosshair", "add_node_lock");
     83    private final Cursor cursorImproveLock = ImageProvider.getCursor("crosshair", "lock");
    8284
    8385    private Color guideColor;
    84     private transient Stroke selectTargetWayStroke;
    85     private transient Stroke moveNodeStroke;
    86     private transient Stroke moveNodeIntersectingStroke;
    87     private transient Stroke addNodeStroke;
    88     private transient Stroke deleteNodeStroke;
    89     private int dotSize;
     86
     87    private static final CachingProperty<BasicStroke> SELECT_TARGET_WAY_STROKE
     88            = new StrokeProperty("improvewayaccuracy.stroke.select-target", "2").cached();
     89    private static final CachingProperty<BasicStroke> MOVE_NODE_STROKE
     90            = new StrokeProperty("improvewayaccuracy.stroke.move-node", "1 6").cached();
     91    private static final CachingProperty<BasicStroke> MOVE_NODE_INTERSECTING_STROKE
     92            = new StrokeProperty("improvewayaccuracy.stroke.move-node-intersecting", "1 2 6").cached();
     93    private static final CachingProperty<BasicStroke> ADD_NODE_STROKE
     94            = new StrokeProperty("improvewayaccuracy.stroke.add-node", "1").cached();
     95    private static final CachingProperty<BasicStroke> DELETE_NODE_STROKE
     96            = new StrokeProperty("improvewayaccuracy.stroke.delete-node", "1").cached();
     97    private static final CachingProperty<Integer> DOT_SIZE
     98            = new IntegerProperty("improvewayaccuracy.dot-size", 6).cached();
    9099
    91100    private boolean selectionChangedBlocked;
     
    111120                KeyEvent.VK_W, Shortcut.DIRECT), mapFrame, Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
    112121
    113         cursorSelect = ImageProvider.getCursor("normal", "mode");
    114         cursorSelectHover = ImageProvider.getCursor("hand", "mode");
    115         cursorImprove = ImageProvider.getCursor("crosshair", null);
    116         cursorImproveAdd = ImageProvider.getCursor("crosshair", "addnode");
    117         cursorImproveDelete = ImageProvider.getCursor("crosshair", "delete_node");
    118         cursorImproveAddLock = ImageProvider.getCursor("crosshair",
    119                 "add_node_lock");
    120         cursorImproveLock = ImageProvider.getCursor("crosshair", "lock");
    121122        readPreferences();
    122123    }
     
    156157        if (guideColor == null)
    157158            guideColor = PaintColors.HIGHLIGHT.get();
    158 
    159         selectTargetWayStroke = GuiHelper.getCustomizedStroke(Main.pref.get("improvewayaccuracy.stroke.select-target", "2"));
    160         moveNodeStroke = GuiHelper.getCustomizedStroke(Main.pref.get("improvewayaccuracy.stroke.move-node", "1 6"));
    161         moveNodeIntersectingStroke = GuiHelper.getCustomizedStroke(Main.pref.get("improvewayaccuracy.stroke.move-node-intersecting", "1 2 6"));
    162         addNodeStroke = GuiHelper.getCustomizedStroke(Main.pref.get("improvewayaccuracy.stroke.add-node", "1"));
    163         deleteNodeStroke = GuiHelper.getCustomizedStroke(Main.pref.get("improvewayaccuracy.stroke.delete-node", "1"));
    164         dotSize = Main.pref.getInteger("improvewayaccuracy.dot-size", 6);
    165159    }
    166160
     
    190184    @Override
    191185    public String getModeHelpText() {
    192         if (state == State.selecting) {
     186        if (state == State.SELECTING) {
    193187            if (targetWay != null) {
    194188                return tr("Click on the way to start improving its shape.");
     
    234228        g.setColor(guideColor);
    235229
    236         if (state == State.selecting && targetWay != null) {
     230        if (state == State.SELECTING && targetWay != null) {
    237231            // Highlighting the targetWay in Selecting state
    238232            // Non-native highlighting is used, because sometimes highlighted
    239233            // segments are covered with others, which is bad.
    240             g.setStroke(selectTargetWayStroke);
     234            g.setStroke(SELECT_TARGET_WAY_STROKE.get());
    241235
    242236            List<Node> nodes = targetWay.getNodes();
    243237
    244             MapPath2D b = new MapPath2D();
    245             Point p0 = mv.getPoint(nodes.get(0));
    246             Point pn;
    247             b.moveTo(p0.x, p0.y);
    248 
    249             for (Node n : nodes) {
    250                 pn = mv.getPoint(n);
    251                 b.lineTo(pn.x, pn.y);
    252             }
    253             if (targetWay.isClosed()) {
    254                 b.lineTo(p0.x, p0.y);
    255             }
    256 
    257             g.draw(b);
    258 
    259         } else if (state == State.improving) {
     238            g.draw(new MapViewPath(mv).append(nodes, false));
     239
     240        } else if (state == State.IMPROVING) {
    260241            // Drawing preview lines and highlighting the node
    261242            // that is going to be moved.
     
    263244
    264245            // Finding endpoints
    265             Point p1 = null, p2 = null;
     246            Node p1 = null;
     247            Node p2 = null;
    266248            if (ctrl && candidateSegment != null) {
    267                 g.setStroke(addNodeStroke);
    268                 p1 = mv.getPoint(candidateSegment.getFirstNode());
    269                 p2 = mv.getPoint(candidateSegment.getSecondNode());
     249                g.setStroke(ADD_NODE_STROKE.get());
     250                p1 = candidateSegment.getFirstNode();
     251                p2 = candidateSegment.getSecondNode();
    270252            } else if (!alt && !ctrl && candidateNode != null) {
    271                 g.setStroke(moveNodeStroke);
     253                g.setStroke(MOVE_NODE_STROKE.get());
    272254                List<Pair<Node, Node>> wpps = targetWay.getNodePairs(false);
    273255                for (Pair<Node, Node> wpp : wpps) {
    274256                    if (wpp.a == candidateNode) {
    275                         p1 = mv.getPoint(wpp.b);
     257                        p1 = wpp.b;
    276258                    }
    277259                    if (wpp.b == candidateNode) {
    278                         p2 = mv.getPoint(wpp.a);
     260                        p2 = wpp.a;
    279261                    }
    280262                    if (p1 != null && p2 != null) {
     
    283265                }
    284266            } else if (alt && !ctrl && candidateNode != null) {
    285                 g.setStroke(deleteNodeStroke);
     267                g.setStroke(DELETE_NODE_STROKE.get());
    286268                List<Node> nodes = targetWay.getNodes();
    287269                int index = nodes.indexOf(candidateNode);
     
    289271                // Only draw line if node is not first and/or last
    290272                if (index != 0 && index != (nodes.size() - 1)) {
    291                     p1 = mv.getPoint(nodes.get(index - 1));
    292                     p2 = mv.getPoint(nodes.get(index + 1));
     273                    p1 = nodes.get(index - 1);
     274                    p2 = nodes.get(index + 1);
    293275                } else if (targetWay.isClosed()) {
    294                     p1 = mv.getPoint(targetWay.getNode(1));
    295                     p2 = mv.getPoint(targetWay.getNode(nodes.size() - 2));
     276                    p1 = targetWay.getNode(1);
     277                    p2 = targetWay.getNode(nodes.size() - 2);
    296278                }
    297279                // TODO: indicate what part that will be deleted? (for end nodes)
     
    300282
    301283            // Drawing preview lines
    302             MapPath2D b = new MapPath2D();
     284            MapViewPath b = new MapViewPath(mv);
    303285            if (alt && !ctrl) {
    304286                // In delete mode
    305287                if (p1 != null && p2 != null) {
    306                     b.moveTo(p1.x, p1.y);
    307                     b.lineTo(p2.x, p2.y);
     288                    b.moveTo(p1);
     289                    b.lineTo(p2);
    308290                }
    309291            } else {
     
    311293                if (p1 != null) {
    312294                    b.moveTo(mousePos.x, mousePos.y);
    313                     b.lineTo(p1.x, p1.y);
     295                    b.lineTo(p1);
    314296                }
    315297                if (p2 != null) {
    316298                    b.moveTo(mousePos.x, mousePos.y);
    317                     b.lineTo(p2.x, p2.y);
     299                    b.lineTo(p2);
    318300                }
    319301            }
     
    322304            // Highlighting candidateNode
    323305            if (candidateNode != null) {
    324                 p1 = mv.getPoint(candidateNode);
    325                 g.fillRect(p1.x - dotSize/2, p1.y - dotSize/2, dotSize, dotSize);
     306                p1 = candidateNode;
     307                g.fill(new MapViewPath(mv).shapeAround(p1, SymbolShape.SQUARE, DOT_SIZE.get()));
    326308            }
    327309
     
    329311                b.reset();
    330312                drawIntersectingWayHelperLines(mv, b);
    331                 g.setStroke(moveNodeIntersectingStroke);
     313                g.setStroke(MOVE_NODE_INTERSECTING_STROKE.get());
    332314                g.draw(b);
    333315            }
     
    336318    }
    337319
    338     protected void drawIntersectingWayHelperLines(MapView mv, MapPath2D b) {
     320    protected void drawIntersectingWayHelperLines(MapView mv, MapViewPath b) {
    339321        for (final OsmPrimitive referrer : candidateNode.getReferrers()) {
    340322            if (!(referrer instanceof Way) || targetWay.equals(referrer)) {
     
    347329                }
    348330                if (i > 0) {
    349                     final MapViewPoint p = mv.getState().getPointFor(nodes.get(i - 1));
    350331                    b.moveTo(mousePos.x, mousePos.y);
    351                     b.lineTo(p);
     332                    b.lineTo(nodes.get(i - 1));
    352333                }
    353334                if (i < nodes.size() - 1) {
    354                     final MapViewPoint p = mv.getState().getPointFor(nodes.get(i + 1));
    355335                    b.moveTo(mousePos.x, mousePos.y);
    356                     b.lineTo(p);
     336                    b.lineTo(nodes.get(i + 1));
    357337                }
    358338            }
     
    414394        mousePos = e.getPoint();
    415395
    416         if (state == State.selecting) {
     396        if (state == State.SELECTING) {
    417397            if (targetWay != null) {
    418398                getLayerManager().getEditDataSet().setSelected(targetWay.getPrimitiveId());
    419399                updateStateByCurrentSelection();
    420400            }
    421         } else if (state == State.improving && mousePos != null) {
     401        } else if (state == State.IMPROVING && mousePos != null) {
    422402            // Checking if the new coordinate is outside of the world
    423403            if (mv.getLatLon(mousePos.x, mousePos.y).isOutSideWorld()) {
     
    553533        }
    554534
    555         if (state == State.selecting) {
     535        if (state == State.SELECTING) {
    556536            mv.setNewCursor(targetWay == null ? cursorSelect
    557537                    : cursorSelectHover, this);
    558         } else if (state == State.improving) {
     538        } else if (state == State.IMPROVING) {
    559539            if (alt && !ctrl) {
    560540                mv.setNewCursor(cursorImproveDelete, this);
     
    578558     */
    579559    public void updateCursorDependentObjectsIfNeeded() {
    580         if (state == State.improving && (shift || dragging)
     560        if (state == State.IMPROVING && (shift || dragging)
    581561                && !(candidateNode == null && candidateSegment == null)) {
    582562            return;
     
    589569        }
    590570
    591         if (state == State.selecting) {
     571        if (state == State.SELECTING) {
    592572            targetWay = ImproveWayAccuracyHelper.findWay(mv, mousePos);
    593         } else if (state == State.improving) {
     573        } else if (state == State.IMPROVING) {
    594574            if (ctrl && !alt) {
    595575                candidateSegment = ImproveWayAccuracyHelper.findCandidateSegment(mv,
     
    608588     */
    609589    public void startSelecting() {
    610         state = State.selecting;
     590        state = State.SELECTING;
    611591
    612592        targetWay = null;
     
    622602     */
    623603    public void startImproving(Way targetWay) {
    624         state = State.improving;
     604        state = State.IMPROVING;
    625605
    626606        DataSet ds = getLayerManager().getEditDataSet();
  • trunk/src/org/openstreetmap/josm/actions/mapmode/ParallelWayAction.java

    r10874 r10875  
    3333import org.openstreetmap.josm.data.osm.Way;
    3434import org.openstreetmap.josm.data.osm.WaySegment;
    35 import org.openstreetmap.josm.data.osm.visitor.paint.MapPath2D;
    3635import org.openstreetmap.josm.data.osm.visitor.paint.PaintColors;
    3736import org.openstreetmap.josm.data.preferences.AbstractToStringProperty;
     
    4544import org.openstreetmap.josm.gui.MapView;
    4645import org.openstreetmap.josm.gui.Notification;
     46import org.openstreetmap.josm.gui.draw.MapViewPath;
    4747import org.openstreetmap.josm.gui.layer.Layer;
    4848import org.openstreetmap.josm.gui.layer.MapViewPaintable;
     
    468468            g.setStroke(REF_LINE_STROKE.get());
    469469            g.setColor(mainColor);
    470             MapPath2D line = new MapPath2D();
    471             line.moveTo(mv.getState().getPointFor(referenceSegment.getFirstNode()));
    472             line.lineTo(mv.getState().getPointFor(referenceSegment.getSecondNode()));
     470            MapViewPath line = new MapViewPath(mv);
     471            line.moveTo(referenceSegment.getFirstNode());
     472            line.lineTo(referenceSegment.getSecondNode());
    473473            g.draw(line);
    474474
    475475            g.setStroke(HELPER_LINE_STROKE.get());
    476476            g.setColor(mainColor);
    477             line = new MapPath2D();
    478             line.moveTo(mv.getState().getPointFor(helperLineStart));
    479             line.lineTo(mv.getState().getPointFor(helperLineEnd));
     477            line = new MapViewPath(mv);
     478            line.moveTo(helperLineStart);
     479            line.lineTo(helperLineEnd);
    480480            g.draw(line);
    481481        }
Note: See TracChangeset for help on using the changeset viewer.