Ignore:
Timestamp:
2014-03-24T22:35:16+01:00 (12 years ago)
Author:
donvip
Message:

[josm_turnrestrictions] code cleanup

Location:
applications/editors/josm/plugins/turnrestrictions
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • applications/editors/josm/plugins/turnrestrictions/src/org/openstreetmap/josm/plugins/turnrestrictions/TurnRestrictionBuilder.java

    r25845 r30365  
    2424 */
    2525public class TurnRestrictionBuilder {
    26        
    27         /**
    28         * Replies the angle phi in the polar coordinates (r,phi) representing the first
    29         * segment of the way {@code w}, where w is moved such that the start node of {@code w} is
    30         * in the origin (0,0).
    31         * 
    32         * @param w the way.  Must not be null. At least two nodes required.
    33         * @return phi in the polar coordinates
    34         * @throws IllegalArgumentException thrown if w is null
    35         * @throws IllegalArgumentException thrown if w is too short (at least two nodes required)
    36         */
     26   
     27    /**
     28    * Replies the angle phi in the polar coordinates (r,phi) representing the first
     29    * segment of the way {@code w}, where w is moved such that the start node of {@code w} is
     30    * in the origin (0,0).
     31    * 
     32    * @param w the way.  Must not be null. At least two nodes required.
     33    * @return phi in the polar coordinates
     34    * @throws IllegalArgumentException thrown if w is null
     35    * @throws IllegalArgumentException thrown if w is too short (at least two nodes required)
     36    */
    3737    static public double phi(Way w) throws IllegalArgumentException{
    38         return phi(w, false /* not inverse */);
     38        return phi(w, false /* not inverse */);
    3939    }
    4040   
    4141    /**
    4242     * <p>Replies the angle phi in the polar coordinates (r,phi) representing the first
    43         * segment of the way {@code w}, where w is moved such that the start node of {@code w} is
    44         * in the origin (0,0).</p>
    45         *
    46         * <p>If {@code doInvert} is true, computes phi for the way in reversed direction.</p>
    47         *
    48         * @param w the way.  Must not be null. At least two nodes required.
    49         * @param doInvert if true, computes phi for the reversed way
    50         * @return phi in the polar coordinates
    51         * @throws IllegalArgumentException thrown if w is null
    52         * @throws IllegalArgumentException thrown if w is too short (at least two nodes required)
     43    * segment of the way {@code w}, where w is moved such that the start node of {@code w} is
     44    * in the origin (0,0).</p>
     45    *
     46    * <p>If {@code doInvert} is true, computes phi for the way in reversed direction.</p>
     47    *
     48    * @param w the way.  Must not be null. At least two nodes required.
     49    * @param doInvert if true, computes phi for the reversed way
     50    * @return phi in the polar coordinates
     51    * @throws IllegalArgumentException thrown if w is null
     52    * @throws IllegalArgumentException thrown if w is too short (at least two nodes required)
    5353     */
    5454    static public double phi(Way w, boolean doInvert) throws IllegalArgumentException {
    55         CheckParameterUtil.ensureParameterNotNull(w, "w");
    56         if (w.getNodesCount() < 2) {
    57                 throw new IllegalArgumentException("can't compute phi for way with less than 2 nodes");
    58         }
    59         List<Node> nodes = w.getNodes();
    60         if (doInvert) Collections.reverse(nodes);
    61         Node n0 = nodes.get(0);
    62         Node n1 = nodes.get(1);
    63        
    64         double x = n1.getCoor().getX() - n0.getCoor().getX();
    65         double y = n1.getCoor().getY() - n0.getCoor().getY();
    66         return Math.atan2(y, x);       
     55        CheckParameterUtil.ensureParameterNotNull(w, "w");
     56        if (w.getNodesCount() < 2) {
     57            throw new IllegalArgumentException("can't compute phi for way with less than 2 nodes");
     58        }
     59        List<Node> nodes = w.getNodes();
     60        if (doInvert) Collections.reverse(nodes);
     61        Node n0 = nodes.get(0);
     62        Node n1 = nodes.get(1);
     63       
     64        double x = n1.getCoor().getX() - n0.getCoor().getX();
     65        double y = n1.getCoor().getY() - n0.getCoor().getY();
     66        return Math.atan2(y, x);     
    6767    }   
    6868
    … …  
    7777     */
    7878    static public Node getUniqueCommonNode(Way w1, Way w2) throws IllegalArgumentException{
    79         Set<Node> w1Nodes = new HashSet<Node>(w1.getNodes());
    80         w1Nodes.retainAll(w2.getNodes());
    81         if (w1Nodes.size() != 1) return null;
    82         return w1Nodes.iterator().next();
     79        Set<Node> w1Nodes = new HashSet<Node>(w1.getNodes());
     80        w1Nodes.retainAll(w2.getNodes());
     81        if (w1Nodes.size() != 1) return null;
     82        return w1Nodes.iterator().next();
    8383    }   
    8484       
    … …  
    9191     */
    9292    static public boolean isStartNode(Way w, Node n) {
    93         if (w.getNodesCount() == 0) return false;
    94         return w.getNode(0).equals(n);
     93        if (w.getNodesCount() == 0) return false;
     94        return w.getNode(0).equals(n);
    9595    }
    9696       
    … …  
    103103     */
    104104    static public boolean isEndNode(Way w, Node n){
    105         if (w.getNodesCount() == 0) return false;
    106         return w.getNode(w.getNodesCount()-1).equals(n);
     105        if (w.getNodesCount() == 0) return false;
     106        return w.getNode(w.getNodesCount()-1).equals(n);
    107107    }
    108108   
    … …  
    116116     */
    117117    static public boolean isInnerNode(Way w, Node n){
    118         if (!w.getNodes().contains(n)) return false;
    119         if (isStartNode(w, n)) return false;
    120         if (isEndNode(w, n)) return false;
    121         return true;            
     118        if (!w.getNodes().contains(n)) return false;
     119        if (isStartNode(w, n)) return false;
     120        if (isEndNode(w, n)) return false;
     121        return true;        
    122122    }
    123123   
    … …  
    140140     */
    141141    static public double intersectionAngle(Way from, Way to) throws IllegalArgumentException {
    142             Node via = getUniqueCommonNode(from, to);
    143             if (via == null) 
    144                 throw new IllegalArgumentException("the two ways must share exactly one common node"); // no I18n required
    145             if (!isStartNode(from, via) && ! isEndNode(from, via)) 
    146                 throw new IllegalArgumentException("via node must be start or end node of from-way"); // no I18n required
    147             if (!isStartNode(to, via) && ! isEndNode(to, via)) 
    148                 throw new IllegalArgumentException("via node must be start or end node of to-way"); // no I18n required
    149             double phi1 = phi(from, isStartNode(from, via));
    150             double phi2 = phi(to, isEndNode(to, via));         
    151                 return phi1 - phi2;
     142        Node via = getUniqueCommonNode(from, to);
     143        if (via == null)
     144            throw new IllegalArgumentException("the two ways must share exactly one common node"); // no I18n required
     145        if (!isStartNode(from, via) && ! isEndNode(from, via))
     146            throw new IllegalArgumentException("via node must be start or end node of from-way"); // no I18n required
     147        if (!isStartNode(to, via) && ! isEndNode(to, via))
     148            throw new IllegalArgumentException("via node must be start or end node of to-way"); // no I18n required
     149        double phi1 = phi(from, isStartNode(from, via));
     150        double phi2 = phi(to, isEndNode(to, via));
     151        return phi1 - phi2;
    152152    }   
    153153       
    154154    static public enum RelativeWayJoinOrientation {
    155         LEFT,
    156         RIGHT
     155        LEFT,
     156        RIGHT
    157157    }
    158158    /**
    … …  
    188188     */
    189189    public static RelativeWayJoinOrientation determineWayJoinOrientation(Way from, Way to){
    190         Node via = getUniqueCommonNode(from, to);
    191         if (via == null) return null;
    192         if (!isConnectingNode(from, to, via)) return null;
    193         // if either w1 or w2 are closed at the via node, we can't determine automatically
    194         // whether the connection at "via" is a "left turn" or a "right turn"
    195         if (isClosedAt(from, via)) return null;
    196         if (isClosedAt(to, via)) return null;
    197        
    198         double phi = intersectionAngle(from, to);       
    199         if (phi >=0 && phi <= Math.PI) {
    200                 return RelativeWayJoinOrientation.RIGHT;
    201         } else {
    202                 return RelativeWayJoinOrientation.LEFT;
    203         }
     190        Node via = getUniqueCommonNode(from, to);
     191        if (via == null) return null;
     192        if (!isConnectingNode(from, to, via)) return null;
     193        // if either w1 or w2 are closed at the via node, we can't determine automatically
     194        // whether the connection at "via" is a "left turn" or a "right turn"
     195        if (isClosedAt(from, via)) return null;
     196        if (isClosedAt(to, via)) return null;
     197       
     198        double phi = intersectionAngle(from, to);
     199        if (phi >=0 && phi <= Math.PI) {
     200            return RelativeWayJoinOrientation.RIGHT;
     201        } else {
     202            return RelativeWayJoinOrientation.LEFT;
     203        }
    204204    }
    205205   
    … …  
    241241     */
    242242    static public Way selectToWayAfterSplit(Way from, Way to1, Way to2, TurnRestrictionType restrictionType){
    243         if (restrictionType == null) return null;
    244         Node cn1 = TurnRestrictionBuilder.getUniqueCommonNode(from, to1);
    245         if (cn1 == null) return null;
    246         Node cn2 = TurnRestrictionBuilder.getUniqueCommonNode(from, to2);
    247         if (cn2 == null) return null;
    248         if (cn1 != cn2) return null;           
    249        
    250         if (! isStartNode(from, cn1) && ! isEndNode(from, cn1)) {
    251                 /*
    252                 * the now split to-way still *intersects* the from-way. We
    253                 * can't adjust the split decisions. 
    254                 */
    255                 return null;
    256         }
    257        
    258         RelativeWayJoinOrientation o1 = determineWayJoinOrientation(from, to1);
    259         RelativeWayJoinOrientation o2 = determineWayJoinOrientation(from, to2);
    260        
     243        if (restrictionType == null) return null;
     244        Node cn1 = TurnRestrictionBuilder.getUniqueCommonNode(from, to1);
     245        if (cn1 == null) return null;
     246        Node cn2 = TurnRestrictionBuilder.getUniqueCommonNode(from, to2);
     247        if (cn2 == null) return null;
     248        if (cn1 != cn2) return null;
     249       
     250        if (! isStartNode(from, cn1) && ! isEndNode(from, cn1)) {
     251            /*
     252            * the now split to-way still *intersects* the from-way. We
     253            * can't adjust the split decisions.
     254            */
     255            return null;
     256        }
     257       
     258        RelativeWayJoinOrientation o1 = determineWayJoinOrientation(from, to1);
     259        RelativeWayJoinOrientation o2 = determineWayJoinOrientation(from, to2);
     260       
    261261        switch(restrictionType){
    262262        case NO_LEFT_TURN:
    263263        case ONLY_LEFT_TURN:
    264                 if (RelativeWayJoinOrientation.LEFT.equals(o1)) return to1;
    265                 else if (RelativeWayJoinOrientation.LEFT.equals(o2)) return to2;
    266                 else return null;
    267                
     264            if (RelativeWayJoinOrientation.LEFT.equals(o1)) return to1;
     265            else if (RelativeWayJoinOrientation.LEFT.equals(o2)) return to2;
     266            else return null;
     267           
    268268        case NO_RIGHT_TURN:
    269269        case ONLY_RIGHT_TURN:
    270                 if (RelativeWayJoinOrientation.RIGHT.equals(o1)) return to1;
    271                 else if (RelativeWayJoinOrientation.RIGHT.equals(o2)) return to2;
    272                 else return null;
    273                
     270            if (RelativeWayJoinOrientation.RIGHT.equals(o1)) return to1;
     271            else if (RelativeWayJoinOrientation.RIGHT.equals(o2)) return to2;
     272            else return null;
     273           
    274274        default:
    275                  /*
    276                   * For restriction types like NO_U_TURN, NO_STRAIGHT_ON, etc. we
    277                   * can select a "left" or "right" way after splitting.
    278                   */
    279                 return null;
     275               /*
     276                 * For restriction types like NO_U_TURN, NO_STRAIGHT_ON, etc. we
     277                 * can select a "left" or "right" way after splitting.
     278                 */
     279            return null;
    280280        }
    281281    }
    … …  
    308308     */
    309309    protected Relation initNoUTurnRestriction(List<OsmPrimitive> primitives) {
    310         if (primitives.size() != 2) return null;
    311                
    312         // we need exactly one node and one way in the selection ...
    313         List<Node> nodes = OsmPrimitive.getFilteredList(primitives, Node.class);
    314         List<Way> ways = OsmPrimitive.getFilteredList(primitives, Way.class);
    315         if (nodes.size() != 1 || ways.size() != 1) return null;
    316        
    317         // .. and the node has to be the start or the node of the way
    318         Way way = ways.get(0);
    319         Node node = nodes.get(0);
    320         List<Node> wayNodes = way.getNodes();
    321         if (wayNodes.size() < 2) return null; // shouldn't happen - just in case
    322         if (! (wayNodes.get(0).equals(node) ||wayNodes.get(wayNodes.size()-1).equals(node))) return null;
    323 
    324         Relation tr = new Relation();
    325         tr.put("type", "restriction");
    326         tr.addMember(new RelationMember("from", way));
    327         tr.addMember(new RelationMember("to", way));
    328         tr.addMember(new RelationMember("via", node));
    329         tr.put("restriction", TurnRestrictionType.NO_U_TURN.getTagValue());
    330         return tr;     
     310        if (primitives.size() != 2) return null;
     311               
     312        // we need exactly one node and one way in the selection ...
     313        List<Node> nodes = OsmPrimitive.getFilteredList(primitives, Node.class);
     314        List<Way> ways = OsmPrimitive.getFilteredList(primitives, Way.class);
     315        if (nodes.size() != 1 || ways.size() != 1) return null;
     316       
     317        // .. and the node has to be the start or the node of the way
     318        Way way = ways.get(0);
     319        Node node = nodes.get(0);
     320        List<Node> wayNodes = way.getNodes();
     321        if (wayNodes.size() < 2) return null; // shouldn't happen - just in case
     322        if (! (wayNodes.get(0).equals(node) ||wayNodes.get(wayNodes.size()-1).equals(node))) return null;
     323
     324        Relation tr = new Relation();
     325        tr.put("type", "restriction");
     326        tr.addMember(new RelationMember("from", way));
     327        tr.addMember(new RelationMember("to", way));
     328        tr.addMember(new RelationMember("via", node));
     329        tr.put("restriction", TurnRestrictionType.NO_U_TURN.getTagValue());
     330        return tr;
    331331    }
    332332
    … …  
    344344     */
    345345    public static boolean isConnectingNode(Way w1, Way w2, Node n){
    346         if (isStartNode(w1, n)) {
    347                 return isStartNode(w2, n)  | isEndNode(w2, n);
    348         } else if (isEndNode(w1, n)){
    349                 return isStartNode(w2, n)  | isEndNode(w2, n);
    350         }
    351         return false;
     346        if (isStartNode(w1, n)) {
     347            return isStartNode(w2, n)  | isEndNode(w2, n);
     348        } else if (isEndNode(w1, n)){
     349            return isStartNode(w2, n)  | isEndNode(w2, n);
     350        }
     351        return false;
    352352    }
    353353   
    … …  
    360360     */
    361361    public static boolean isClosedAt(Way w, Node n){
    362         List<Node> nodes = w.getNodes();
    363         nodes.retainAll(Collections.singletonList(n));
    364         return nodes.size() >= 2;
     362        List<Node> nodes = w.getNodes();
     363        nodes.retainAll(Collections.singletonList(n));
     364        return nodes.size() >= 2;
    365365    }
    366366   
    367367    protected Relation initTurnRestrictionFromTwoWays(List<OsmPrimitive> primitives) {
    368         Way w1 = null;
    369         Way w2 = null;
    370         Node via = null;
    371         if (primitives.size() == 2) {
    372                 // if we have exactly two selected primitives, we expect two ways.
    373                 // See initNoUTurnRestriction() for the case where we have a selected way
    374                 // and a selected node
    375                 List<Way> selWays = OsmPrimitive.getFilteredList(primitives, Way.class);
    376                 if (selWays.size() != 2) return null;
    377                 w1 = selWays.get(0);
    378                 w2 = selWays.get(1);
    379                 via = getUniqueCommonNode(w1, w2);             
    380         } else if (primitives.size() == 3){
    381                 // if we have exactly three selected primitives, we need two ways and a
    382                 // node, which should be an acceptable via node
    383                 List<Way> selWays = OsmPrimitive.getFilteredList(primitives, Way.class);
    384                 List<Node> selNodes = OsmPrimitive.getFilteredList(primitives, Node.class);
    385                 if (selWays.size() != 2) return null;
    386                 if (selNodes.size() != 1) return null;
    387                 w1 = selWays.get(0);
    388                 w2 = selWays.get(1);
    389                 via = selNodes.get(0);
    390                 if (! w1.getNodes().contains(via) || ! w2.getNodes().contains(via)){
    391                         // the selected node is not an acceptable via node
    392                         via = null;
    393                 }
    394         } else {
    395                 // the selection doesn't consists of primitives for which we can build
    396                 // a turn restriction
    397                 return null;
    398         }
    399        
    400         // if we get here, we know the two "legs" of the turn restriction. We may
    401         // or may not know a via node, though
    402         assert w1 != null;
    403         assert w2 != null;
    404        
    405         Relation tr = new Relation();
    406         tr.put("type", "restriction");
    407         tr.addMember(new RelationMember("from", w1));
    408         tr.addMember(new RelationMember("to", w2));
    409        
    410         if (via != null){
    411                 tr.addMember(new RelationMember("via", via));
    412                 RelativeWayJoinOrientation orientation = determineWayJoinOrientation(w1, w2);
    413                 if (orientation != null){
    414                         switch(orientation){
    415                         case LEFT:
    416                                 tr.put("restriction", TurnRestrictionType.NO_LEFT_TURN.getTagValue());
    417                                 break;
    418                         case RIGHT:
    419                                 tr.put("restriction", TurnRestrictionType.NO_RIGHT_TURN.getTagValue());
    420                                 break;                                 
    421                         }
    422                 }
    423         }
    424         return tr;
     368        Way w1 = null;
     369        Way w2 = null;
     370        Node via = null;
     371        if (primitives.size() == 2) {
     372            // if we have exactly two selected primitives, we expect two ways.
     373            // See initNoUTurnRestriction() for the case where we have a selected way
     374            // and a selected node
     375            List<Way> selWays = OsmPrimitive.getFilteredList(primitives, Way.class);
     376            if (selWays.size() != 2) return null;
     377            w1 = selWays.get(0);
     378            w2 = selWays.get(1);
     379            via = getUniqueCommonNode(w1, w2);
     380        } else if (primitives.size() == 3){
     381            // if we have exactly three selected primitives, we need two ways and a
     382            // node, which should be an acceptable via node
     383            List<Way> selWays = OsmPrimitive.getFilteredList(primitives, Way.class);
     384            List<Node> selNodes = OsmPrimitive.getFilteredList(primitives, Node.class);
     385            if (selWays.size() != 2) return null;
     386            if (selNodes.size() != 1) return null;
     387            w1 = selWays.get(0);
     388            w2 = selWays.get(1);
     389            via = selNodes.get(0);
     390            if (! w1.getNodes().contains(via) || ! w2.getNodes().contains(via)){
     391                // the selected node is not an acceptable via node
     392                via = null;
     393            }
     394        } else {
     395            // the selection doesn't consists of primitives for which we can build
     396            // a turn restriction
     397            return null;
     398        }
     399       
     400        // if we get here, we know the two "legs" of the turn restriction. We may
     401        // or may not know a via node, though
     402        assert w1 != null;
     403        assert w2 != null;
     404       
     405        Relation tr = new Relation();
     406        tr.put("type", "restriction");
     407        tr.addMember(new RelationMember("from", w1));
     408        tr.addMember(new RelationMember("to", w2));
     409       
     410        if (via != null){
     411            tr.addMember(new RelationMember("via", via));
     412            RelativeWayJoinOrientation orientation = determineWayJoinOrientation(w1, w2);
     413            if (orientation != null){
     414                switch(orientation){
     415                case LEFT:
     416                    tr.put("restriction", TurnRestrictionType.NO_LEFT_TURN.getTagValue());
     417                    break;
     418                case RIGHT:
     419                    tr.put("restriction", TurnRestrictionType.NO_RIGHT_TURN.getTagValue());
     420                    break;                   
     421                }
     422            }
     423        }
     424        return tr;
    425425    }
    426426       
    427427    protected Relation initEmptyTurnRestriction() {
    428            Relation tr = new Relation();
     428       Relation tr = new Relation();
    429429       tr.put("type", "restriction");
    430430       return tr;
    … …  
    441441    public synchronized Relation build(List<OsmPrimitive> primitives){
    442442        if (primitives == null || primitives.isEmpty()) {
    443                 return initEmptyTurnRestriction();
     443            return initEmptyTurnRestriction();
    444444        }
    445445        Relation tr;
    … …  
    447447        // case 0 already handled
    448448        case 1:
    449                 tr = initEmptyTurnRestriction();
    450                 if (OsmPrimitive.getFilteredList(primitives, Way.class).size() == 1) {     
    451                         // we have exactly one selected way? -> init the "from" leg
    452                         // of the turn restriction with it
    453                         tr.addMember(new RelationMember("from", primitives.get(0)));
    454                 }
    455                 return tr;
    456                
     449            tr = initEmptyTurnRestriction();
     450            if (OsmPrimitive.getFilteredList(primitives, Way.class).size() == 1) {     
     451                // we have exactly one selected way? -> init the "from" leg
     452                // of the turn restriction with it
     453                tr.addMember(new RelationMember("from", primitives.get(0)));
     454            }
     455            return tr;
     456           
    457457        case 2:
    458                 tr = initNoUTurnRestriction(primitives);
    459                 if (tr != null) return tr;
    460                 tr = initTurnRestrictionFromTwoWays(primitives);
    461                 if (tr != null) return tr;
    462                 return initEmptyTurnRestriction();       
    463                
    464         default:               
    465                 tr = initTurnRestrictionFromTwoWays(primitives);
    466                 if (tr != null) return tr;
    467                 return initEmptyTurnRestriction();       
     458            tr = initNoUTurnRestriction(primitives);
     459            if (tr != null) return tr;
     460            tr = initTurnRestrictionFromTwoWays(primitives);
     461            if (tr != null) return tr;
     462            return initEmptyTurnRestriction();
     463           
     464        default:
     465            tr = initTurnRestrictionFromTwoWays(primitives);
     466            if (tr != null) return tr;
     467            return initEmptyTurnRestriction();       
    468468        }
    469469    }       

  • applications/editors/josm/plugins/turnrestrictions/src/org/openstreetmap/josm/plugins/turnrestrictions/editor/BasicEditorPanel.java

    r29854 r30365  
    9292        DefaultListSelectionModel selectionModel = new DefaultListSelectionModel();
    9393        spVias = new JScrollPane(lstVias = new ViaList(new ViaListModel(model, selectionModel), selectionModel)) {
    94                 // fixes #6016 : Scrollbar hides field entry
    95                 public Dimension getPreferredSize() {
    96                         return new Dimension(100, 80); // only height is relevant, 80 is just a heuristical value
     94            // fixes #6016 : Scrollbar hides field entry
     95            public Dimension getPreferredSize() {
     96                return new Dimension(100, 80); // only height is relevant, 80 is just a heuristical value
    9797             }
    9898        };

  • applications/editors/josm/plugins/turnrestrictions/src/org/openstreetmap/josm/plugins/turnrestrictions/editor/JosmSelectionListModel.java

    r29854 r30365  
    119119        // select it in the list of selected JOSM objects too.
    120120        if (getSelected().isEmpty() && this.selection.size() == 1) {
    121                 setSelected(this.selection);
     121            setSelected(this.selection);
    122122        }
    123123    }
    … …  
    143143       
    144144    public ListSelectionModel getListSelectionModel() {
    145         return selectionModel;
     145        return selectionModel;
    146146    }
    147147

  • applications/editors/josm/plugins/turnrestrictions/src/org/openstreetmap/josm/plugins/turnrestrictions/editor/RelationMemberEditorModel.java

    r29854 r30365  
    445445
    446446    public int getRowCount() {
    447         return members.size();
     447        return members.size();
    448448    }
    449449

  • applications/editors/josm/plugins/turnrestrictions/src/org/openstreetmap/josm/plugins/turnrestrictions/editor/TurnRestrictionEditorModel.java

    r29854 r30365  
    9494     */
    9595    public JosmSelectionListModel getJosmSelectionListModel() {
    96         return selectionModel;
     96        return selectionModel;
    9797    }
    9898   

  • applications/editors/josm/plugins/turnrestrictions/src/org/openstreetmap/josm/plugins/turnrestrictions/editor/TurnRestrictionLegEditor.java

    r29854 r30365  
    278278     */
    279279    class AcceptAction extends AbstractAction implements ListSelectionListener {
    280        
    281         public AcceptAction() {
    282                         putValue(SHORT_DESCRIPTION, tr("Accept the currently selected way"));
    283                  putValue(NAME, tr("Accept"));
    284                  putValue(SMALL_ICON, ImageProvider.get("accept"));
    285                  model.getJosmSelectionListModel().getListSelectionModel().addListSelectionListener(this);
    286                  updateEnabledState();           
    287         }
    288        
    289         public void actionPerformed(ActionEvent e) {
    290                 List<Way> selWays = OsmPrimitive.getFilteredList(model.getJosmSelectionListModel().getSelected(), Way.class);
    291                 if (selWays.size() != 1) return;
    292                 Way w = selWays.get(0);                 
     280       
     281        public AcceptAction() {
     282            putValue(SHORT_DESCRIPTION, tr("Accept the currently selected way"));
     283             putValue(NAME, tr("Accept"));
     284             putValue(SMALL_ICON, ImageProvider.get("accept"));
     285             model.getJosmSelectionListModel().getListSelectionModel().addListSelectionListener(this);
     286             updateEnabledState();
     287        }
     288       
     289        public void actionPerformed(ActionEvent e) {
     290            List<Way> selWays = OsmPrimitive.getFilteredList(model.getJosmSelectionListModel().getSelected(), Way.class);
     291            if (selWays.size() != 1) return;
     292            Way w = selWays.get(0);
    293293             model.setTurnRestrictionLeg(role, w);           
    294294         }       
    295295         
    296296         public void updateEnabledState() {
    297                 setEnabled(OsmPrimitive.getFilteredList(model.getJosmSelectionListModel().getSelected(), Way.class).size() == 1);
     297            setEnabled(OsmPrimitive.getFilteredList(model.getJosmSelectionListModel().getSelected(), Way.class).size() == 1);
    298298         }
    299299
    300                 @Override
    301                 public void valueChanged(ListSelectionEvent e) {
    302                         updateEnabledState();
    303                 }
     300        @Override
     301        public void valueChanged(ListSelectionEvent e) {
     302            updateEnabledState();
     303        }
    304304    }
    305305   

  • applications/editors/josm/plugins/turnrestrictions/src/org/openstreetmap/josm/plugins/turnrestrictions/editor/VehicleExceptionEditor.java

    r29854 r30365  
    232232   
    233233    protected void init() {
    234         try {
    235                 // temporarily disable the checkbox listeners while initializing the
    236                 // checkboxes with the input value
    237                 this.svtChangeListener.setEnabled(false);
    238                 cbPsv.setSelected(exceptValue.isVehicleException("psv"));
    239                 cbBicyle.setSelected(exceptValue.isVehicleException("bicycle"));
    240                 cbMotorcar.setSelected(exceptValue.isVehicleException("motorcar"));
    241                 cbHgv.setSelected(exceptValue.isVehicleException("hgv"));
    242         } finally {
    243                 this.svtChangeListener.setEnabled(true);
    244         }
     234        try {
     235            // temporarily disable the checkbox listeners while initializing the
     236            // checkboxes with the input value
     237            this.svtChangeListener.setEnabled(false);
     238            cbPsv.setSelected(exceptValue.isVehicleException("psv"));
     239            cbBicyle.setSelected(exceptValue.isVehicleException("bicycle"));
     240            cbMotorcar.setSelected(exceptValue.isVehicleException("motorcar"));
     241            cbHgv.setSelected(exceptValue.isVehicleException("hgv"));
     242        } finally {
     243            this.svtChangeListener.setEnabled(true);
     244        }
    245245        if (!exceptValue.isStandard()){
    246246            rbNonStandardException.setSelected(true);
    … …  
    309309   
    310310    class StandardVehicleTypeChangeListener implements ItemListener {
    311         private boolean enabled = true;
    312        
    313         public void setEnabled(boolean enabled){
    314                 this.enabled = enabled;
    315         }
    316        
    317         public void itemStateChanged(ItemEvent e) {             
    318                 if (!enabled) return;
     311        private boolean enabled = true;
     312       
     313        public void setEnabled(boolean enabled){
     314            this.enabled = enabled;
     315        }
     316       
     317        public void itemStateChanged(ItemEvent e) {
     318            if (!enabled) return;
    319319            exceptValue.setVehicleException("bicycle", cbBicyle.isSelected());
    320320            exceptValue.setVehicleException("hgv", cbHgv.isSelected());

  • applications/editors/josm/plugins/turnrestrictions/src/org/openstreetmap/josm/plugins/turnrestrictions/editor/ViaList.java

    r29854 r30365  
    9393    }
    9494   
    95         /**
     95    /**
    9696     * The transfer handler for Drag-and-Drop.
    9797     */

  • applications/editors/josm/plugins/turnrestrictions/src/org/openstreetmap/josm/plugins/turnrestrictions/qa/IssuesModel.java

    r23593 r30365  
    212212                issues.add(new IntersectionMissingAsViaError(this, from, to, intersect));
    213213            }
    214                 if (isInnerNode(from, intersect) && isInnerNode(to, intersect)) {
    215                         issues.add(new TurnRestrictionLegSplitRequiredError(this, from, to));
    216                 } else if (isInnerNode(from, intersect) && ! isInnerNode(to, intersect)) {
    217                         issues.add(new TurnRestrictionLegSplitRequiredError(this, TurnRestrictionLegRole.FROM, from, to, intersect));
    218                 } else if (!isInnerNode(from, intersect) && isInnerNode(to, intersect)) {
    219                         issues.add(new TurnRestrictionLegSplitRequiredError(this, TurnRestrictionLegRole.TO, from, to, intersect));
    220                 }
     214            if (isInnerNode(from, intersect) && isInnerNode(to, intersect)) {
     215                issues.add(new TurnRestrictionLegSplitRequiredError(this, from, to));
     216            } else if (isInnerNode(from, intersect) && ! isInnerNode(to, intersect)) {
     217                issues.add(new TurnRestrictionLegSplitRequiredError(this, TurnRestrictionLegRole.FROM, from, to, intersect));
     218            } else if (!isInnerNode(from, intersect) && isInnerNode(to, intersect)) {
     219                issues.add(new TurnRestrictionLegSplitRequiredError(this, TurnRestrictionLegRole.TO, from, to, intersect));
     220            }
    221221        } else {
    222                 if (editorModel.getVias().isEmpty() && ! from.equals(to)){
    223                         // the two turn restriction legs aren't connected and we don't have configured
    224                         // via objects
    225                         issues.add(new MissingViaError(this));
    226                 }               
     222            if (editorModel.getVias().isEmpty() && ! from.equals(to)){
     223                // the two turn restriction legs aren't connected and we don't have configured
     224                // via objects
     225                issues.add(new MissingViaError(this));
     226            }
    227227        }               
    228228    }

  • applications/editors/josm/plugins/turnrestrictions/src/org/openstreetmap/josm/plugins/turnrestrictions/qa/MissingViaError.java

    r23571 r30365  
    1414public class MissingViaError extends Issue {
    1515
    16         public MissingViaError(IssuesModel parent) throws IllegalArgumentException {
    17                 super(parent, Severity.WARNING);
    18                 actions.add(new FixAction());
    19         }
     16    public MissingViaError(IssuesModel parent) throws IllegalArgumentException {
     17        super(parent, Severity.WARNING);
     18        actions.add(new FixAction());
     19    }
    2020
    21         @Override
    22         public String getText() {
    23                 String msg =
    24                         tr("The two ways participating in the turn restriction <strong>aren''t connected.</strong>")
    25                         + "<p>"
    26                         + tr("Make sure you add one or more via objects (nodes or ways) to the turn restriction.");
    27                 return msg;
    28         }
     21    @Override
     22    public String getText() {
     23        String msg =
     24            tr("The two ways participating in the turn restriction <strong>aren''t connected.</strong>")
     25            + "<p>"
     26            + tr("Make sure you add one or more via objects (nodes or ways) to the turn restriction.");
     27        return msg;
     28    }
    2929
    30         class FixAction extends AbstractAction {
     30    class FixAction extends AbstractAction {
    3131        public FixAction() {
    3232            putValue(NAME, tr("Fix in editor"));

  • applications/editors/josm/plugins/turnrestrictions/src/org/openstreetmap/josm/plugins/turnrestrictions/qa/TurnRestrictionLegSplitRequiredError.java

    r25845 r30365  
    2828 */
    2929public class TurnRestrictionLegSplitRequiredError extends Issue{
    30         static private final Logger logger = Logger.getLogger(TurnRestrictionLegSplitRequiredError.class.getName());
    31        
     30    static private final Logger logger = Logger.getLogger(TurnRestrictionLegSplitRequiredError.class.getName());
     31   
    3232    private TurnRestrictionLegRole role;
    3333    private Way from;
    … …  
    4545     */
    4646    public TurnRestrictionLegSplitRequiredError(IssuesModel parent, Way from, Way to){
    47         super(parent, Severity.ERROR);
    48         CheckParameterUtil.ensureParameterNotNull(from, "from");
    49         CheckParameterUtil.ensureParameterNotNull(to, "to"); 
    50        
    51         intersect= TurnRestrictionBuilder.getUniqueCommonNode(from, to);
    52         if (intersect == null)
    53                 throw new IllegalArgumentException("exactly one intersecting node required");
    54        
    55         this.from = from;
    56         this.to = to;
    57         this.role = null;
    58         actions.add(new SplitAction());
     47        super(parent, Severity.ERROR);
     48        CheckParameterUtil.ensureParameterNotNull(from, "from");
     49        CheckParameterUtil.ensureParameterNotNull(to, "to");
     50       
     51        intersect= TurnRestrictionBuilder.getUniqueCommonNode(from, to);
     52        if (intersect == null)
     53            throw new IllegalArgumentException("exactly one intersecting node required");
     54       
     55        this.from = from;
     56        this.to = to;
     57        this.role = null;
     58        actions.add(new SplitAction());
    5959    }
    6060
    … …  
    8181        String msg = null;
    8282        if (role == null){
    83                 /*
    84                 * from and to intersect at a common node. Both have to be split.
    85                 */
    86                 return tr("The way <span class=\"object-name\">{0}</span> with role <tt>from</tt> and the "
    87                                 + "way <span class=\"object-name\">{1}</span> with role <tt>to</tt> intersect "                         
    88                                 + "at node <span class=\"object-name\">{2}</span>. "
    89                                 + "<p> "
    90                                 + "Both ways should be split at the intersecting node.",
     83            /*
     84            * from and to intersect at a common node. Both have to be split.
     85            */
     86            return tr("The way <span class=\"object-name\">{0}</span> with role <tt>from</tt> and the "
     87                    + "way <span class=\"object-name\">{1}</span> with role <tt>to</tt> intersect "                   
     88                    + "at node <span class=\"object-name\">{2}</span>. "
     89                    + "<p> "
     90                    + "Both ways should be split at the intersecting node.",
    9191                    from.getDisplayName(DefaultNameFormatter.getInstance()),
    9292                    to.getDisplayName(DefaultNameFormatter.getInstance()),
    … …  
    9696        switch(role){
    9797        case FROM:
    98                 /*
    99                 * "to" joins "from" at a common node. Only from has to be split
    100                 */
     98            /*
     99            * "to" joins "from" at a common node. Only from has to be split
     100            */
    101101            msg = tr("The way <span class=\"object-name\">{0}</span> with role <tt>{1}</tt> should be split "
    102102                + "at node <span class=\"object-name\">{2}</span> where it connects to way <span class=\"object-name\">{3}</span>.",
    … …  
    108108            break;
    109109        case TO:
    110                 /*
    111                 * "from" joins "to" at a common node. Only to has to be split
    112                 */
     110            /*
     111            * "from" joins "to" at a common node. Only to has to be split
     112            */
    113113            msg = tr("The way <span class=\"object-name\">{0}</span> with role <tt>{1}</tt> should be split "
    114114                    + "at node <span class=\"object-name\">{2}</span> where it connects to way <span class=\"object-name\">{3}</span>.",
    … …  
    131131        public void actionPerformed(ActionEvent e) {
    132132
    133                 SplitWayResult result = null;
     133            SplitWayResult result = null;
    134134            if (role == null || role.equals(TurnRestrictionLegRole.FROM)){
    135                   result = SplitWayAction.split(
     135                  result = SplitWayAction.split(
    136136                          parent.getEditorModel().getLayer(),
    137137                          from,
    … …  
    139139                          Collections.<OsmPrimitive>emptyList()
    140140                  );
    141                   if (result != null){
     141                  if (result != null){
    142142                      Main.main.undoRedo.add(result.getCommand());
    143143                  }
    … …  
    145145           
    146146            if (role == null || role.equals(TurnRestrictionLegRole.TO)) {
    147                 result = SplitWayAction.split(
     147                result = SplitWayAction.split(
    148148                        parent.getEditorModel().getLayer(),
    149149                        to,
    … …  
    151151                        Collections.<OsmPrimitive>emptyList()
    152152                );
    153                 if (result != null){
     153                if (result != null){
    154154                    Main.main.undoRedo.add(result.getCommand());
    155155                }
    156                 if (result == null) return;
    157                         TurnRestrictionType restrictionType = TurnRestrictionType.fromTagValue(getIssuesModel().getEditorModel().getRestrictionTagValue());
    158                     if (restrictionType == null) return;
    159                     Way adjustedTo = TurnRestrictionBuilder.selectToWayAfterSplit(
    160                                 from,
    161                                 result.getOriginalWay(),
    162                                 result.getNewWays().get(0),
    163                                 restrictionType
    164                     );
    165        
    166                     if (adjustedTo == null) return;
    167                     getIssuesModel().getEditorModel().setTurnRestrictionLeg(
    168                                 TurnRestrictionLegRole.TO,
    169                                 adjustedTo
    170                     );       
    171                     getIssuesModel().getEditorModel().getLayer().data.setSelected(
    172                                 Arrays.asList(from, adjustedTo)
    173                      ); 
     156                if (result == null) return;
     157                TurnRestrictionType restrictionType = TurnRestrictionType.fromTagValue(getIssuesModel().getEditorModel().getRestrictionTagValue());
     158                if (restrictionType == null) return;
     159                Way adjustedTo = TurnRestrictionBuilder.selectToWayAfterSplit(
     160                        from,
     161                        result.getOriginalWay(),
     162                        result.getNewWays().get(0),
     163                        restrictionType
     164                );
     165   
     166                if (adjustedTo == null) return;
     167                getIssuesModel().getEditorModel().setTurnRestrictionLeg(
     168                        TurnRestrictionLegRole.TO,
     169                        adjustedTo
     170                );         
     171                getIssuesModel().getEditorModel().getLayer().data.setSelected(
     172                          Arrays.asList(from, adjustedTo)
     173                 );   
    174174            } else {
    175                     getIssuesModel().getEditorModel().getLayer().data.setSelected(
    176                                 Arrays.asList(from, to)
    177                      );                 
     175                getIssuesModel().getEditorModel().getLayer().data.setSelected(
     176                          Arrays.asList(from, to)
     177                 );
    178178            }           
    179179        }

  • applications/editors/josm/plugins/turnrestrictions/test/src/org/openstreetmap/josm/plugins/turnrestrictions/AllUnitTests.java

    r23571 r30365  
    77@RunWith(Suite.class)
    88@Suite.SuiteClasses({
    9         AllEditorTests.class,
    10         TurnRestrictionBuilderTest.class
     9    AllEditorTests.class,
     10    TurnRestrictionBuilderTest.class
    1111})
    1212public class AllUnitTests {}

  • applications/editors/josm/plugins/turnrestrictions/test/src/org/openstreetmap/josm/plugins/turnrestrictions/editor/AllEditorTests.java

    r23571 r30365  
    88@RunWith(Suite.class)
    99@Suite.SuiteClasses({
    10         JosmSelectionListModelTest.class,
    11         TurnRestrictionEditorModelUnitTest.class,
    12         TurnRestrictionLegEditorUnitTest.class,
    13         TurnRestrictionTypeRendererTest.class,
    14         TurnRestrictionTypeTest.class,
    15         ExceptValueModelTest.class
     10    JosmSelectionListModelTest.class,
     11    TurnRestrictionEditorModelUnitTest.class,
     12    TurnRestrictionLegEditorUnitTest.class,
     13    TurnRestrictionTypeRendererTest.class,
     14    TurnRestrictionTypeTest.class,
     15    ExceptValueModelTest.class
    1616})
    1717public class AllEditorTests extends TestCase{}

  • applications/editors/josm/plugins/turnrestrictions/test/src/org/openstreetmap/josm/plugins/turnrestrictions/fixtures/JOSMFixture.java

    r28901 r30365  
    6969        //
    7070        String url = OsmApi.getOsmApi().getBaseUrl().toLowerCase().trim();
    71         if (url.startsWith("http://www.openstreetmap.org")
    72                || url.startsWith("http://api.openstreetmap.org")) {
     71        if (url.startsWith("http://www.openstreetmap.org") || url.startsWith("http://api.openstreetmap.org")
     72         || url.startsWith("https://www.openstreetmap.org") || url.startsWith("https://api.openstreetmap.org")) {
    7373            fail(MessageFormat.format("configured server url ''{0}'' seems to be a productive url, aborting.", url));
    7474        }
Note: See TracChangeset for help on using the changeset viewer.