Changeset 4869 in josm


Ignore:
Timestamp:
2012-01-24T21:52:43+01:00 (8 years ago)
Author:
jttt
Message:

Use final were appropriate

Location:
trunk/src/org/openstreetmap/josm
Files:
33 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/Main.java

    r4774 r4869  
    125125     * The global paste buffer.
    126126     */
    127     public static PrimitiveDeepCopy pasteBuffer = new PrimitiveDeepCopy();
     127    public static final PrimitiveDeepCopy pasteBuffer = new PrimitiveDeepCopy();
    128128    public static Layer pasteSource;
    129129
     
    376376    }
    377377
    378     protected static JPanel contentPanePrivate = new JPanel(new BorderLayout());
     378    protected static final JPanel contentPanePrivate = new JPanel(new BorderLayout());
    379379
    380380    /**
     
    420420    ///////////////////////////////////////////////////////////////////////////
    421421
    422     public static JPanel panel = new JPanel(new BorderLayout());
     422    public static final JPanel panel = new JPanel(new BorderLayout());
    423423
    424424    protected static Rectangle bounds;
  • trunk/src/org/openstreetmap/josm/actions/ExtensionFileFilter.java

    r4533 r4869  
    2626     * list of supported formats
    2727     */
    28     public static ArrayList<FileImporter> importers;
    29 
    30     public static ArrayList<FileExporter> exporters;
     28    public static final ArrayList<FileImporter> importers;
     29
     30    public static final ArrayList<FileExporter> exporters;
    3131
    3232    // add some file types only if the relevant classes are there;
     
    8888                    }
    8989                }
    90         );
     90                );
    9191    }
    9292
     
    198198            if (name.endsWith("."+ext))
    199199                return true;
    200         return false;
     200                return false;
    201201    }
    202202
  • trunk/src/org/openstreetmap/josm/actions/SimplifyWayAction.java

    r4461 r4869  
    5151                JOptionPane.WARNING_MESSAGE,
    5252                HelpUtil.ht("/Action/SimplifyWay#SelectAWayToSimplify")
    53         );
     53                );
    5454    }
    5555
     
    6161                        tr("Simplify all selected ways"),
    6262                        null
    63                 ),
    64                 new ButtonSpec(
    65                         tr("Cancel"),
    66                         ImageProvider.get("cancel"),
    67                         tr("Cancel operation"),
    68                         null
    69                 )
     63                        ),
     64                        new ButtonSpec(
     65                                tr("Cancel"),
     66                                ImageProvider.get("cancel"),
     67                                tr("Cancel operation"),
     68                                null
     69                                )
    7070        };
    7171        int ret = HelpAwareOptionPane.showOptionDialog(
     
    7474                        "The selection contains {0} ways. Are you sure you want to simplify them all?",
    7575                        numWays
    76                 ),
    77                 tr("Simplify ways?"),
    78                 JOptionPane.WARNING_MESSAGE,
    79                 null, // no special icon
    80                 options,
    81                 options[0],
    82                 HelpUtil.ht("/Action/SimplifyWay#ConfirmSimplifyAll")
    83         );
     76                        ),
     77                        tr("Simplify ways?"),
     78                        JOptionPane.WARNING_MESSAGE,
     79                        null, // no special icon
     80                        options,
     81                        options[0],
     82                        HelpUtil.ht("/Action/SimplifyWay#ConfirmSimplifyAll")
     83                );
    8484        return ret == 0;
    8585    }
     
    9494                alertSelectAtLeastOneWay();
    9595                return;
    96             } else if (!confirmWayWithNodesOutsideBoundingBox(ways)) {
     96            } else if (!confirmWayWithNodesOutsideBoundingBox(ways))
    9797                return;
    98             }
    99              else if (ways.size() > 10) {
     98            else if (ways.size() > 10) {
    10099                if (!confirmSimplifyManyWays(ways.size()))
    101100                    return;
     
    114113                    trn("Simplify {0} way", "Simplify {0} ways", allCommands.size(), allCommands.size()),
    115114                    allCommands
    116             );
     115                    );
    117116            Main.main.undoRedo.add(rootCommand);
    118117        } finally {
     
    235234    }
    236235
    237     public static double EARTH_RAD = 6378137.0;
     236    public static final double EARTH_RAD = 6378137.0;
    238237
    239238    /* From Aviaton Formulary v1.3
  • trunk/src/org/openstreetmap/josm/data/coor/LatLon.java

    r4580 r4869  
    11// License: GPL. Copyright 2007 by Immanuel Scholz and others
    22package org.openstreetmap.josm.data.coor;
    3 
    4 import static org.openstreetmap.josm.tools.I18n.trc;
    53
    64import static java.lang.Math.PI;
     
    119import static java.lang.Math.sqrt;
    1210import static java.lang.Math.toRadians;
     11import static org.openstreetmap.josm.tools.I18n.trc;
    1312
    1413import java.math.BigDecimal;
     
    3029public class LatLon extends Coordinate {
    3130
    32    
     31
    3332    /**
    3433     * Minimum difference in location to not be represented as the same position.
     
    4140    private static DecimalFormat cDmsSecondFormatter = new DecimalFormat("00.0");
    4241    private static DecimalFormat cDmMinuteFormatter = new DecimalFormat("00.000");
    43     public static DecimalFormat cDdFormatter;
     42    public static final DecimalFormat cDdFormatter;
    4443    static {
    4544        // Don't use the localized decimal separator. This way we can present
     
    6867        return lon >= -180d && lon <= 180d;
    6968    }
    70                      
    71         /**
    72         * Replies true if lat is in the range [-90,90] and lon is in the range [-180,180]
    73          *
    74         * @return true if lat is in the range [-90,90] and lon is in the range [-180,180]
    75         */
    76         public boolean isValid() {
    77                 return isValidLat(lat()) && isValidLon(lon());
    78         }
    79        
     69
     70    /**
     71    * Replies true if lat is in the range [-90,90] and lon is in the range [-180,180]
     72     *
     73    * @return true if lat is in the range [-90,90] and lon is in the range [-180,180]
     74    */
     75    public boolean isValid() {
     76        return isValidLat(lat()) && isValidLon(lon());
     77    }
     78
    8079    public static double toIntervalLat(double value) {
    8180        if (value < -90)
     
    8887    /**
    8988     * Returns a valid OSM longitude [-180,+180] for the given extended longitude value.
    90      * For example, a value of -181 will return +179, a value of +181 will return -179. 
     89     * For example, a value of -181 will return +179, a value of +181 will return -179.
    9190     * @param lon A longitude value not restricted to the [-180,+180] range.
    9291     */
    9392    public static double toIntervalLon(double value) {
    94         if (isValidLon(value)) {
     93        if (isValidLon(value))
    9594            return value;
    96         } else {
     95        else {
    9796            int n = (int) (value + Math.signum(value)*180.0) / 360;
    9897            return value - n*360.0;
    9998        }
    10099    }
    101        
     100
    102101    /**
    103102     * Replies the coordinate in degrees/minutes/seconds format
     
    180179        Bounds b = Main.getProjection().getWorldBoundsLatLon();
    181180        return lat() < b.getMin().lat() || lat() > b.getMax().lat() ||
    182         lon() < b.getMin().lon() || lon() > b.getMax().lon();
     181                lon() < b.getMin().lon() || lon() > b.getMax().lon();
    183182    }
    184183
     
    220219     * http://math.stackexchange.com/questions/720/how-to-calculate-a-heading-on-the-earths-surface
    221220     * for some hints how it is derived.)
    222      * 
     221     *
    223222     * @param other the "destination" position
    224223     * @return heading in the range 0 <= hd < 2*PI
     
    233232        }
    234233        return hd;
    235      }
     234    }
    236235
    237236    /**
     
    258257        return "LatLon[lat="+lat()+",lon="+lon()+"]";
    259258    }
    260    
     259
    261260    /**
    262261     * Returns the value rounded to OSM precisions, i.e. to
     
    278277    public static double roundToOsmPrecisionStrict(double value) {
    279278        double absV = Math.abs(value);
    280         int numOfDigits = MAX_SERVER_DIGITS + (absV < 1 ? 0 : (absV < 10 ? 1 : (absV < 100 ? 2 : 3))); 
     279        int numOfDigits = MAX_SERVER_DIGITS + (absV < 1 ? 0 : (absV < 10 ? 1 : (absV < 100 ? 2 : 3)));
    281280        return BigDecimal.valueOf(value).round(new MathContext(numOfDigits)).doubleValue();
    282281    }
     
    292291                roundToOsmPrecision(lat()),
    293292                roundToOsmPrecision(lon())
    294         );
     293                );
    295294    }
    296295
     
    305304                roundToOsmPrecisionStrict(lat()),
    306305                roundToOsmPrecisionStrict(lon())
    307         );
     306                );
    308307    }
    309308
  • trunk/src/org/openstreetmap/josm/data/imagery/OffsetBookmark.java

    r4126 r4869  
    2020
    2121public class OffsetBookmark {
    22     public static List<OffsetBookmark> allBookmarks = new ArrayList<OffsetBookmark>();
     22    public static final List<OffsetBookmark> allBookmarks = new ArrayList<OffsetBookmark>();
    2323
    2424    public Projection proj;
  • trunk/src/org/openstreetmap/josm/data/osm/QuadBuckets.java

    r4409 r4869  
    5757    }
    5858
    59     public static int MAX_OBJECTS_PER_LEVEL = 16;
     59    public static final int MAX_OBJECTS_PER_LEVEL = 16;
    6060    class QBLevel
    6161    {
     
    312312                    continue;
    313313                }
    314                 if (found_me) {
     314                if (found_me)
    315315                    /*if (debug) {
    316316                        out("[" + this.level + "] next sibling was child nr: " + nr);
    317317                    }*/
    318318                    return sibling;
    319                 }
    320                 /*if (debug) {
    321                     out("[" + this.level + "] nr: " + nr + " is before me, ignoring...");
    322                 }*/
    323319            }
    324320            return null;
     
    405401                System.out.print("[" + level + "] qb bbox: " + this.bbox() + " ");
    406402            }*/
    407             if (!this.bbox().intersects(search_bbox)) {
     403            if (!this.bbox().intersects(search_bbox))
    408404                /*if (debug) {
    409405                    out("miss " + Long.toHexString(this.quad));
     
    411407                }*/
    412408                return;
    413             } else if (bbox().bounds(search_bbox)) {
     409            else if (bbox().bounds(search_bbox)) {
    414410                search_cache = this;
    415411            }
     
    632628        public boolean hasNext()
    633629        {
    634             if (this.peek() == null) {
     630            if (this.peek() == null)
    635631                /*if (debug) {
    636632                    out(this + " no hasNext(), but iterated over so far: " + iterated_over);
    637633                }*/
    638634                return false;
    639             }
    640635            return true;
    641636        }
    642637        T peek()
    643638        {
    644             if (current_node == null) {
     639            if (current_node == null)
    645640                /*if (debug) {
    646641                    out("null current leaf, nowhere to go");
    647642                }*/
    648643                return null;
    649             }
    650644            while((current_node.content == null) ||
    651645                    (content_index >= current_node.content.size())) {
     
    659653                }
    660654            }
    661             if (current_node == null || current_node.content == null) {
     655            if (current_node == null || current_node.content == null)
    662656                /*if (debug) {
    663657                    out("late nowhere to go " + current_node);
    664658                }*/
    665659                return null;
    666             }
    667660            return current_node.content.get(content_index);
    668661        }
  • trunk/src/org/openstreetmap/josm/data/projection/GaussKrueger.java

    r4304 r4869  
    2222public class GaussKrueger extends AbstractProjection implements ProjectionSubPrefs {
    2323
    24     public static int DEFAULT_ZONE = 2;
     24    public static final int DEFAULT_ZONE = 2;
    2525    private int zone;
    26    
    27     private static Bounds[] bounds = { 
     26
     27    private static Bounds[] bounds = {
    2828        new Bounds(new LatLon(-5, 3.5), new LatLon(85, 8.5)),
    2929        new Bounds(new LatLon(-5, 6.5), new LatLon(85, 11.5)),
     
    3333
    3434    private static NTV2GridShiftFile BETA2007 = null;
    35    
     35
    3636    private static String[] zones = { "2", "3", "4", "5" };
    3737
     
    4545                String gridFileName = "BETA2007.gsb";
    4646                InputStream is = Main.class.getResourceAsStream("/data/"+gridFileName);
    47                 if (is == null) {
     47                if (is == null)
    4848                    throw new RuntimeException(tr("Error: failed to open input stream for resource ''/data/{0}''.", gridFileName));
    49                 }
    5049                BETA2007 = new NTV2GridShiftFile();
    5150                BETA2007.loadGridShiftFile(is, false);
     
    7069    }
    7170
    72     @Override 
     71    @Override
    7372    public String toString() {
    7473        return tr("Gau\u00DF-Kr\u00FCger");
    7574    }
    76    
     75
    7776    @Override
    7877    public Integer getEpsgCode() {
     
    8988        return bounds[zone-2];
    9089    }
    91    
     90
    9291    @Override
    9392    public void setupPreferencePanel(JPanel p, ActionListener listener) {
     
    106105        }
    107106    }
    108    
     107
    109108    @Override
    110109    public Collection<String> getPreferences(JPanel p) {
     
    115114        return Collections.singleton(Integer.toString(zone+2));
    116115    }
    117    
     116
    118117    @Override
    119118    public void setPreferences(Collection<String> args) {
     
    133132        updateParameters(zone);
    134133    }
    135    
     134
    136135    @Override
    137136    public String[] allCodes() {
     
    154153        return null;
    155154    }
    156    
     155
    157156}
  • trunk/src/org/openstreetmap/josm/data/projection/datum/GRS80Datum.java

    r4285 r4869  
    1313public class GRS80Datum extends AbstractDatum {
    1414
    15     public static GRS80Datum INSTANCE = new GRS80Datum();
    16    
     15    public final static GRS80Datum INSTANCE = new GRS80Datum();
     16
    1717    private GRS80Datum() {
    1818        super(tr("GRS80"), null, Ellipsoid.GRS80);
    1919    }
    20    
     20
    2121    @Override
    2222    public LatLon fromWGS84(LatLon ll) {
  • trunk/src/org/openstreetmap/josm/data/projection/datum/WGS84Datum.java

    r4285 r4869  
    1212public class WGS84Datum extends AbstractDatum {
    1313
    14     public static WGS84Datum INSTANCE = new WGS84Datum();
     14    public static final WGS84Datum INSTANCE = new WGS84Datum();
    1515
    1616    private WGS84Datum() {
  • trunk/src/org/openstreetmap/josm/data/validation/OsmValidator.java

    r4682 r4869  
    7272    public static double griddetail;
    7373
    74     public static Collection<String> ignoredErrors = new TreeSet<String>();
     74    public static final Collection<String> ignoredErrors = new TreeSet<String>();
    7575
    7676    /**
  • trunk/src/org/openstreetmap/josm/data/validation/tests/BuildingInBuilding.java

    r4806 r4869  
    2424public class BuildingInBuilding extends Test {
    2525
    26     protected static int BUILDING_INSIDE_BUILDING = 2001;
     26    protected static final int BUILDING_INSIDE_BUILDING = 2001;
    2727    protected List<OsmPrimitive> primitivesToCheck = new LinkedList<OsmPrimitive>();
    2828    protected QuadBuckets<Way> index = new QuadBuckets<Way>();
     
    5757        // Check that all nodes of w are in polygon
    5858        for (Node n : w.getNodes()) {
    59             if (!isInPolygon(n, polygon)) {
     59            if (!isInPolygon(n, polygon))
    6060                return false;
    61             }
    6261        }
    6362        // All nodes can be inside polygon and still, w outside:
     
    7372        for (int i=1; i<w.getNodesCount(); i++) {
    7473            LatLon center = w.getNode(i).getCoor().getCenter(w.getNode(i-1).getCoor());
    75             if (center != null && !isInPolygon(new Node(center), polygon)) {
     74            if (center != null && !isInPolygon(new Node(center), polygon))
    7675                return false;
    77             }
    7876        }
    7977        return true;
     
    8684                @Override
    8785                public boolean evaluate(Way object) {
    88                     if (p.equals(object)) {
     86                    if (p.equals(object))
    8987                        return false;
    90                     } else if (p instanceof Node) {
     88                    else if (p instanceof Node)
    9189                        return isInPolygon((Node) p, object.getNodes()) || object.getNodes().contains(p);
    92                     } else if (p instanceof Way) {
     90                    else if (p instanceof Way)
    9391                        return isInPolygon((Way) p, object.getNodes()) && !isInInnerWay((Way)p, object);
    94                     } else {
     92                    else
    9593                        return false;
    96                     }
    9794                }
    9895            });
     
    103100        }
    104101    }
    105    
     102
    106103    private boolean isInInnerWay(Way w, Way outer) {
    107104        for (OsmPrimitive r : outer.getReferrers()) {
     
    113110                        if (isInPolygon(inner, outer.getNodes())) {
    114111                            // If the tested way is inside this inner, outer is a false positive
    115                             if (isInPolygon(w, inner.getNodes())) {
     112                            if (isInPolygon(w, inner.getNodes()))
    116113                                return true;
    117                             }
    118114                        }
    119115                    }
  • trunk/src/org/openstreetmap/josm/data/validation/tests/Coastlines.java

    r4806 r4869  
    3131public class Coastlines extends Test {
    3232
    33     protected static int UNORDERED_COASTLINE = 901;
    34     protected static int REVERSED_COASTLINE = 902;
    35     protected static int UNCONNECTED_COASTLINE = 903;
     33    protected static final int UNORDERED_COASTLINE = 901;
     34    protected static final int REVERSED_COASTLINE = 902;
     35    protected static final int UNCONNECTED_COASTLINE = 903;
    3636
    3737    private List<Way> coastlines;
  • trunk/src/org/openstreetmap/josm/data/validation/tests/CrossingWays.java

    r4806 r4869  
    2929 */
    3030public class CrossingWays extends Test {
    31     protected static int CROSSING_WAYS = 601;
     31    protected static final int CROSSING_WAYS = 601;
    3232
    3333    /** All way segments, grouped by cells */
     
    4343    public CrossingWays() {
    4444        super(tr("Crossing ways"),
    45               tr("This test checks if two roads, railways, waterways or buildings crosses in the same layer, but are not connected by a node."));
     45                tr("This test checks if two roads, railways, waterways or buildings crosses in the same layer, but are not connected by a node."));
    4646    }
    4747
     
    8282
    8383        String layer1 = w.get("layer");
    84         if ("0".equals(layer1)) layer1 = null; //0 is default value
     84        if ("0".equals(layer1)) {
     85            layer1 = null; //0 is default value
     86        }
    8587
    8688        int nodesSize = w.getNodesCount();
     
    9496                    List<WaySegment> highlight;
    9597
    96                     if (errorSegments.contains(ws) && errorSegments.contains(es2.ws))
    97                         continue;
     98                    if (errorSegments.contains(ws) && errorSegments.contains(es2.ws)) {
     99                        continue;
     100                    }
    98101
    99102                    String layer2 = es2.layer;
    100103                    String railway2 = es2.railway;
    101104                    boolean isCoastline2 = es2.coastline;
    102                     if (layer1 == null ? layer2 != null : !layer1.equals(layer2))
    103                         continue;
    104 
    105                     if (!es1.intersects(es2) ) continue;
    106                     if (isSubway1 && "subway".equals(railway2)) continue;
    107                     if (isTram1 && "tram".equals(railway2)) continue;
    108 
    109                     if (isCoastline1 != isCoastline2) continue;
     105                    if (layer1 == null ? layer2 != null : !layer1.equals(layer2)) {
     106                        continue;
     107                    }
     108
     109                    if (!es1.intersects(es2) ) {
     110                        continue;
     111                    }
     112                    if (isSubway1 && "subway".equals(railway2)) {
     113                        continue;
     114                    }
     115                    if (isTram1 && "tram".equals(railway2)) {
     116                        continue;
     117                    }
     118
     119                    if (isCoastline1 != isCoastline2) {
     120                        continue;
     121                    }
    110122                    if (("river".equals(waterway1) && "riverbank".equals(es2.waterway))
    111                             || ("riverbank".equals(waterway1) && "river".equals(es2.waterway))) continue;
     123                            || ("riverbank".equals(waterway1) && "river".equals(es2.waterway))) {
     124                        continue;
     125                    }
    112126
    113127                    if ((es1.railway != null && es1.railway.equals("abandoned"))
    114                             || (railway2 != null && railway2.equals("abandoned"))) continue;
     128                            || (railway2 != null && railway2.equals("abandoned"))) {
     129                        continue;
     130                    }
    115131
    116132                    prims = Arrays.asList(es1.ws.way, es2.ws.way);
     
    131147
    132148                        errors.add(new TestError(this, Severity.WARNING,
    133                             message,
    134                             CROSSING_WAYS,
    135                             prims,
    136                             highlight));
     149                                message,
     150                                CROSSING_WAYS,
     151                                prims,
     152                                highlight));
    137153                        ways_seen.put(prims, highlight);
    138154                    } else {
     
    147163
    148164    /**
    149     * Returns all the cells this segment crosses.  Each cell contains the list
    150     * of segments already processed
    151     *
    152     * @param n1 The first node
    153     * @param n2 The second node
    154     * @return A list with all the cells the segment crosses
    155     */
     165     * Returns all the cells this segment crosses.  Each cell contains the list
     166     * of segments already processed
     167     *
     168     * @param n1 The first node
     169     * @param n2 The second node
     170     * @return A list with all the cells the segment crosses
     171     */
    156172    public List<List<ExtendedSegment>> getSegments(Node n1, Node n2) {
    157173
     
    218234
    219235            return Line2D.linesIntersect(
    220                 n1.getEastNorth().east(), n1.getEastNorth().north(),
    221                 n2.getEastNorth().east(), n2.getEastNorth().north(),
    222                 s2.n1.getEastNorth().east(), s2.n1.getEastNorth().north(),
    223                 s2.n2.getEastNorth().east(), s2.n2.getEastNorth().north());
     236                    n1.getEastNorth().east(), n1.getEastNorth().north(),
     237                    n2.getEastNorth().east(), n2.getEastNorth().north(),
     238                    s2.n1.getEastNorth().east(), s2.n1.getEastNorth().north(),
     239                    s2.n2.getEastNorth().east(), s2.n2.getEastNorth().north());
    224240        }
    225241    }
  • trunk/src/org/openstreetmap/josm/data/validation/tests/DuplicateNode.java

    r4806 r4869  
    55import static org.openstreetmap.josm.tools.I18n.tr;
    66
    7 import java.awt.GridBagLayout;
    8 import java.awt.geom.Area;
    97import java.util.ArrayList;
    108import java.util.Collection;
     
    1614import java.util.Map;
    1715import java.util.Set;
    18 
    19 import javax.swing.JLabel;
    20 import javax.swing.JOptionPane;
    21 import javax.swing.JPanel;
    2216
    2317import org.openstreetmap.josm.Main;
     
    3529import org.openstreetmap.josm.data.validation.Test;
    3630import org.openstreetmap.josm.data.validation.TestError;
    37 import org.openstreetmap.josm.gui.ConditionalOptionPaneUtil;
    3831import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    3932import org.openstreetmap.josm.tools.MultiMap;
     
    5447                    Math.round(o.getCoor().lat() / precision) * precision,
    5548                    Math.round(o.getCoor().lon() / precision) * precision
    56             );
     49                    );
    5750        }
    5851
     
    8275    }
    8376
    84     protected static int DUPLICATE_NODE = 1;
    85     protected static int DUPLICATE_NODE_MIXED = 2;
    86     protected static int DUPLICATE_NODE_OTHER = 3;
    87     protected static int DUPLICATE_NODE_UNCLOSED = 4;
    88     protected static int DUPLICATE_NODE_BUILDING = 10;
    89     protected static int DUPLICATE_NODE_BOUNDARY = 11;
    90     protected static int DUPLICATE_NODE_HIGHWAY = 12;
    91     protected static int DUPLICATE_NODE_LANDUSE = 13;
    92     protected static int DUPLICATE_NODE_NATURAL = 14;
    93     protected static int DUPLICATE_NODE_POWER = 15;
    94     protected static int DUPLICATE_NODE_RAILWAY = 16;
    95     protected static int DUPLICATE_NODE_WATERWAY = 17;
     77    protected final static int DUPLICATE_NODE = 1;
     78    protected final static int DUPLICATE_NODE_MIXED = 2;
     79    protected final static int DUPLICATE_NODE_OTHER = 3;
     80    protected final static int DUPLICATE_NODE_UNCLOSED = 4;
     81    protected final static int DUPLICATE_NODE_BUILDING = 10;
     82    protected final static int DUPLICATE_NODE_BOUNDARY = 11;
     83    protected final static int DUPLICATE_NODE_HIGHWAY = 12;
     84    protected final static int DUPLICATE_NODE_LANDUSE = 13;
     85    protected final static int DUPLICATE_NODE_NATURAL = 14;
     86    protected final static int DUPLICATE_NODE_POWER = 15;
     87    protected final static int DUPLICATE_NODE_RAILWAY = 16;
     88    protected final static int DUPLICATE_NODE_WATERWAY = 17;
    9689
    9790    /** The map of potential duplicates.
     
    204197                            DUPLICATE_NODE_UNCLOSED,
    205198                            mm.get(tagSet)
    206                     ));
     199                            ));
    207200                } else if (nbType>1) {
    208201                    String msg = marktr("Mixed type duplicated nodes");
     
    215208                            DUPLICATE_NODE_MIXED,
    216209                            mm.get(tagSet)
    217                     ));
     210                            ));
    218211                } else if (typeMap.get("highway")) {
    219212                    String msg = marktr("Highway duplicated nodes");
     
    226219                            DUPLICATE_NODE_HIGHWAY,
    227220                            mm.get(tagSet)
    228                     ));
     221                            ));
    229222                } else if (typeMap.get("railway")) {
    230223                    String msg = marktr("Railway duplicated nodes");
     
    237230                            DUPLICATE_NODE_RAILWAY,
    238231                            mm.get(tagSet)
    239                     ));
     232                            ));
    240233                } else if (typeMap.get("waterway")) {
    241234                    String msg = marktr("Waterway duplicated nodes");
     
    248241                            DUPLICATE_NODE_WATERWAY,
    249242                            mm.get(tagSet)
    250                     ));
     243                            ));
    251244                } else if (typeMap.get("boundary")) {
    252245                    String msg = marktr("Boundary duplicated nodes");
     
    259252                            DUPLICATE_NODE_BOUNDARY,
    260253                            mm.get(tagSet)
    261                     ));
     254                            ));
    262255                } else if (typeMap.get("power")) {
    263256                    String msg = marktr("Power duplicated nodes");
     
    270263                            DUPLICATE_NODE_POWER,
    271264                            mm.get(tagSet)
    272                     ));
     265                            ));
    273266                } else if (typeMap.get("natural")) {
    274267                    String msg = marktr("Natural duplicated nodes");
     
    281274                            DUPLICATE_NODE_NATURAL,
    282275                            mm.get(tagSet)
    283                     ));
     276                            ));
    284277                } else if (typeMap.get("building")) {
    285278                    String msg = marktr("Building duplicated nodes");
     
    292285                            DUPLICATE_NODE_BUILDING,
    293286                            mm.get(tagSet)
    294                     ));
     287                            ));
    295288                } else if (typeMap.get("landuse")) {
    296289                    String msg = marktr("Landuse duplicated nodes");
     
    303296                            DUPLICATE_NODE_LANDUSE,
    304297                            mm.get(tagSet)
    305                     ));
     298                            ));
    306299                } else {
    307300                    String msg = marktr("Other duplicated nodes");
     
    314307                            DUPLICATE_NODE_OTHER,
    315308                            mm.get(tagSet)
    316                     ));
     309                            ));
    317310
    318311                }
     
    336329                        DUPLICATE_NODE,
    337330                        duplicates
    338                 ));
     331                        ));
    339332            }
    340333        }
  • trunk/src/org/openstreetmap/josm/data/validation/tests/DuplicateRelation.java

    r4806 r4869  
    122122    }
    123123
    124     protected static int DUPLICATE_RELATION = 1901;
    125     protected static int SAME_RELATION = 1902;
     124    protected static final int DUPLICATE_RELATION = 1901;
     125    protected static final int SAME_RELATION = 1902;
    126126
    127127    /** MultiMap of all relations */
  • trunk/src/org/openstreetmap/josm/data/validation/tests/DuplicateWay.java

    r4806 r4869  
    7373    }
    7474
    75     protected static int DUPLICATE_WAY = 1401;
    76     protected static int SAME_WAY = 1402;
     75    protected static final int DUPLICATE_WAY = 1401;
     76    protected static final int SAME_WAY = 1402;
    7777
    7878    /** Bag of all ways */
     
    8787    public DuplicateWay() {
    8888        super(tr("Duplicated ways"),
    89               tr("This test checks that there are no ways with same node coordinates and optionally also same tags."));
     89                tr("This test checks that there are no ways with same node coordinates and optionally also same tags."));
    9090    }
    9191
     
    127127                    }
    128128                }
    129                 if (skip) continue;
     129                if (skip) {
     130                    continue;
     131                }
    130132                TestError testError = new TestError(this, Severity.WARNING, tr("Ways with same position"), SAME_WAY, sameway);
    131133                errors.add(testError);
     
    137139
    138140    /**
    139      * Remove uninteresting keys, like created_by to normalize the tags 
     141     * Remove uninteresting keys, like created_by to normalize the tags
    140142     */
    141143    public void removeUninterestingKeys(Map<String, String> wkeys) {
  • trunk/src/org/openstreetmap/josm/data/validation/tests/DuplicatedWayNodes.java

    r4806 r4869  
    1818
    1919public class DuplicatedWayNodes extends Test {
    20     protected static int DUPLICATE_WAY_NODE = 501;
     20    protected static final int DUPLICATE_WAY_NODE = 501;
    2121
    2222    public DuplicatedWayNodes() {
    2323        super(tr("Duplicated way nodes"),
    24             tr("Checks for ways with identical consecutive nodes."));
     24                tr("Checks for ways with identical consecutive nodes."));
    2525    }
    2626
     
    3737            if (lastN == n) {
    3838                errors.add(new TestError(this, Severity.ERROR, tr("Duplicated way nodes"), DUPLICATE_WAY_NODE,
    39                     Arrays.asList(w), Arrays.asList(n)));
     39                        Arrays.asList(w), Arrays.asList(n)));
    4040                break;
    4141            }
     
    5959            lastN = n;
    6060        }
    61         if (wnew.getNodesCount() < 2) {
     61        if (wnew.getNodesCount() < 2)
    6262            // Empty way, delete
    6363            return DeleteCommand.delete(Main.map.mapView.getEditLayer(), Collections.singleton(w));
    64         } else {
     64        else
    6565            return new ChangeCommand(w, wnew);
    66         }
    6766    }
    6867
  • trunk/src/org/openstreetmap/josm/data/validation/tests/NodesWithSameName.java

    r3671 r4869  
    44import static org.openstreetmap.josm.tools.I18n.tr;
    55
    6 import java.util.Map;
    7 import java.util.List;
     6import java.util.ArrayList;
    87import java.util.HashMap;
    98import java.util.HashSet;
    10 import java.util.ArrayList;
     9import java.util.List;
     10import java.util.Map;
    1111
    1212import org.openstreetmap.josm.data.osm.Node;
     
    1717
    1818public class NodesWithSameName extends Test {
    19     protected static int SAME_NAME = 801;
     19    protected static final int SAME_NAME = 801;
    2020
    2121    private Map<String, List<Node>> namesToNodes;
     
    2323    public NodesWithSameName() {
    2424        super(tr("Nodes with same name"),
    25             tr("This test finds nodes that have the same name (might be duplicates)."));
     25                tr("This test finds nodes that have the same name (might be duplicates)."));
    2626    }
    2727
  • trunk/src/org/openstreetmap/josm/data/validation/tests/OverlappingAreas.java

    r4806 r4869  
    55import java.util.Collection;
    66import java.util.Collections;
     7
    78import org.openstreetmap.josm.data.osm.QuadBuckets;
    89import org.openstreetmap.josm.data.osm.Way;
     
    1718public class OverlappingAreas extends Test {
    1819
    19     protected static int OVERLAPPING_AREAS = 2201;
     20    protected static final int OVERLAPPING_AREAS = 2201;
    2021    protected QuadBuckets<Way> index = new QuadBuckets<Way>();
    2122
     
    4041                        @Override
    4142                        public boolean evaluate(Way wi) {
    42                             if (w.equals(wi)) {
     43                            if (w.equals(wi))
    4344                                return false;
    44                             } else {
     45                            else
    4546                                return Geometry.polygonIntersection(w.getNodes(), wi.getNodes())
    4647                                        == Geometry.PolygonIntersection.CROSSING;
    47                             }
    4848                        }
    4949                    });
  • trunk/src/org/openstreetmap/josm/data/validation/tests/OverlappingWays.java

    r4806 r4869  
    2929 */
    3030public class OverlappingWays extends Test {
    31    
     31
    3232    /** Bag of all way segments */
    3333    MultiMap<Pair<Node,Node>, WaySegment> nodePairs;
    3434
    35     protected static int OVERLAPPING_HIGHWAY = 101;
    36     protected static int OVERLAPPING_RAILWAY = 102;
    37     protected static int OVERLAPPING_WAY = 103;
    38     protected static int OVERLAPPING_HIGHWAY_AREA = 111;
    39     protected static int OVERLAPPING_RAILWAY_AREA = 112;
    40     protected static int OVERLAPPING_WAY_AREA = 113;
    41     protected static int OVERLAPPING_AREA = 120;
     35    protected static final int OVERLAPPING_HIGHWAY = 101;
     36    protected static final int OVERLAPPING_RAILWAY = 102;
     37    protected static final int OVERLAPPING_WAY = 103;
     38    protected static final int OVERLAPPING_HIGHWAY_AREA = 111;
     39    protected static final int OVERLAPPING_RAILWAY_AREA = 112;
     40    protected static final int OVERLAPPING_WAY_AREA = 113;
     41    protected static final int OVERLAPPING_AREA = 120;
    4242
    4343    /** Constructor */
    4444    public OverlappingWays() {
    4545        super(tr("Overlapping ways"),
    46               tr("This test checks that a connection between two nodes "
    47                 + "is not used by more than one way."));
     46                tr("This test checks that a connection between two nodes "
     47                        + "is not used by more than one way."));
    4848    }
    4949
     
    125125                    }
    126126
    127                     errors.add(new TestError(this, 
     127                    errors.add(new TestError(this,
    128128                            type < OVERLAPPING_HIGHWAY_AREA ? Severity.WARNING : Severity.OTHER,
    129                             errortype, type, prims, duplicated));
     129                                    errortype, type, prims, duplicated));
    130130                    ways_seen.put(current_ways, duplicated);
    131131                } else { /* way seen, mark highlight layer only */
     
    151151            }
    152152            nodePairs.put(Pair.sort(new Pair<Node,Node>(lastN, n)),
    153                 new WaySegment(w, i));
     153                    new WaySegment(w, i));
    154154            lastN = n;
    155155        }
  • trunk/src/org/openstreetmap/josm/data/validation/tests/RelationChecker.java

    r4806 r4869  
    2828public class RelationChecker extends Test {
    2929
    30     protected static int ROLE_UNKNOWN      = 1701;
    31     protected static int ROLE_EMPTY        = 1702;
    32     protected static int WRONG_TYPE        = 1703;
    33     protected static int HIGH_COUNT        = 1704;
    34     protected static int LOW_COUNT         = 1705;
    35     protected static int ROLE_MISSING      = 1706;
    36     protected static int RELATION_UNKNOWN  = 1707;
    37     protected static int RELATION_EMPTY    = 1708;
     30    protected static final int ROLE_UNKNOWN      = 1701;
     31    protected static final int ROLE_EMPTY        = 1702;
     32    protected static final int WRONG_TYPE        = 1703;
     33    protected static final int HIGH_COUNT        = 1704;
     34    protected static final int LOW_COUNT         = 1705;
     35    protected static final int ROLE_MISSING      = 1706;
     36    protected static final int RELATION_UNKNOWN  = 1707;
     37    protected static final int RELATION_EMPTY    = 1708;
    3838
    3939    /**
  • trunk/src/org/openstreetmap/josm/data/validation/tests/SelfIntersectingWay.java

    r3671 r4869  
    44import static org.openstreetmap.josm.tools.I18n.tr;
    55
     6import java.util.Arrays;
    67import java.util.HashSet;
    7 import java.util.Arrays;
    88
     9import org.openstreetmap.josm.data.osm.Node;
    910import org.openstreetmap.josm.data.osm.Way;
    10 import org.openstreetmap.josm.data.osm.Node;
    1111import org.openstreetmap.josm.data.validation.Severity;
    1212import org.openstreetmap.josm.data.validation.Test;
     
    1717 */
    1818public class SelfIntersectingWay extends Test {
    19    
    20     protected static int SELF_INTERSECT = 401;
     19
     20    protected static final int SELF_INTERSECT = 401;
    2121
    2222    public SelfIntersectingWay() {
    2323        super(tr("Self-intersecting ways"),
    24               tr("This test checks for ways " +
    25                 "that contain some of their nodes more than once."));
     24                tr("This test checks for ways " +
     25                        "that contain some of their nodes more than once."));
    2626    }
    2727
     
    3333            if (nodes.contains(n)) {
    3434                errors.add(new TestError(this,
    35                     Severity.WARNING, tr("Self-intersecting ways"), SELF_INTERSECT,
    36                     Arrays.asList(w), Arrays.asList(n)));
     35                        Severity.WARNING, tr("Self-intersecting ways"), SELF_INTERSECT,
     36                        Arrays.asList(w), Arrays.asList(n)));
    3737                break;
    3838            } else {
  • trunk/src/org/openstreetmap/josm/data/validation/tests/SimilarNamedWays.java

    r4806 r4869  
    2828public class SimilarNamedWays extends Test {
    2929
    30     protected static int SIMILAR_NAMED = 701;
     30    protected static final int SIMILAR_NAMED = 701;
    3131
    3232    /** All ways, grouped by cells */
  • trunk/src/org/openstreetmap/josm/data/validation/tests/TagChecker.java

    r4812 r4869  
    4949import org.openstreetmap.josm.data.osm.Relation;
    5050import org.openstreetmap.josm.data.osm.Way;
    51 import org.openstreetmap.josm.data.validation.OsmValidator;
    5251import org.openstreetmap.josm.data.validation.Severity;
    5352import org.openstreetmap.josm.data.validation.Test;
    5453import org.openstreetmap.josm.data.validation.TestError;
    5554import org.openstreetmap.josm.data.validation.util.Entities;
     55import org.openstreetmap.josm.gui.preferences.TaggingPresetPreference;
    5656import org.openstreetmap.josm.gui.preferences.ValidatorPreference;
    57 import org.openstreetmap.josm.gui.preferences.TaggingPresetPreference;
    5857import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    5958import org.openstreetmap.josm.gui.tagging.TaggingPreset;
     
    7978    protected static MultiMap<String, String> presetsValueData;
    8079    /** The TagChecker data */
    81     protected static List<CheckerData> checkerData = new ArrayList<CheckerData>();
    82     protected static List<String> ignoreDataStartsWith = new ArrayList<String>();
    83     protected static List<String> ignoreDataEquals = new ArrayList<String>();
    84     protected static List<String> ignoreDataEndsWith = new ArrayList<String>();
    85     protected static List<IgnoreKeyPair> ignoreDataKeyPair = new ArrayList<IgnoreKeyPair>();
    86     protected static List<IgnoreTwoKeyPair> ignoreDataTwoKeyPair = new ArrayList<IgnoreTwoKeyPair>();
     80    protected static final List<CheckerData> checkerData = new ArrayList<CheckerData>();
     81    protected static final List<String> ignoreDataStartsWith = new ArrayList<String>();
     82    protected static final List<String> ignoreDataEquals = new ArrayList<String>();
     83    protected static final List<String> ignoreDataEndsWith = new ArrayList<String>();
     84    protected static final List<IgnoreKeyPair> ignoreDataKeyPair = new ArrayList<IgnoreKeyPair>();
     85    protected static final List<IgnoreTwoKeyPair> ignoreDataTwoKeyPair = new ArrayList<IgnoreTwoKeyPair>();
    8786
    8887    /** The preferences prefix */
     
    129128    protected JButton deleteSrcButton;
    130129
    131     protected static int EMPTY_VALUES      = 1200;
    132     protected static int INVALID_KEY       = 1201;
    133     protected static int INVALID_VALUE     = 1202;
    134     protected static int FIXME             = 1203;
    135     protected static int INVALID_SPACE     = 1204;
    136     protected static int INVALID_KEY_SPACE = 1205;
    137     protected static int INVALID_HTML      = 1206; /* 1207 was PAINT */
    138     protected static int LONG_VALUE        = 1208;
    139     protected static int LONG_KEY          = 1209;
    140     protected static int LOW_CHAR_VALUE    = 1210;
    141     protected static int LOW_CHAR_KEY      = 1211;
     130    protected static final int EMPTY_VALUES      = 1200;
     131    protected static final int INVALID_KEY       = 1201;
     132    protected static final int INVALID_VALUE     = 1202;
     133    protected static final int FIXME             = 1203;
     134    protected static final int INVALID_SPACE     = 1204;
     135    protected static final int INVALID_KEY_SPACE = 1205;
     136    protected static final int INVALID_HTML      = 1206; /* 1207 was PAINT */
     137    protected static final int LONG_VALUE        = 1208;
     138    protected static final int LONG_KEY          = 1209;
     139    protected static final int LOW_CHAR_VALUE    = 1210;
     140    protected static final int LOW_CHAR_KEY      = 1211;
    142141    /** 1250 and up is used by tagcheck */
    143142
     
    145144    protected JList sourcesList;
    146145
    147     protected static Entities entities = new Entities();
     146    protected static final Entities entities = new Entities();
    148147
    149148    /**
     
    626625                                tr("Information"),
    627626                                JOptionPane.INFORMATION_MESSAGE
    628                         );
     627                                );
    629628                    }
    630629                } else {
     
    713712    public void handlePrefEnable() {
    714713        boolean selected = prefCheckKeys.isSelected() || prefCheckKeysBeforeUpload.isSelected()
    715                     || prefCheckComplex.isSelected() || prefCheckComplexBeforeUpload.isSelected();
     714                || prefCheckComplex.isSelected() || prefCheckComplexBeforeUpload.isSelected();
    716715        sourcesList.setEnabled( selected );
    717716        addSrcButton.setEnabled(selected);
     
    792791        if (commands.size() == 1)
    793792            return commands.get(0);
    794        
     793
    795794        return new SequenceCommand(tr("Fix properties"), commands);
    796795    }
     
    825824        private int code;
    826825        protected Severity severity;
    827         protected static int TAG_CHECK_ERROR  = 1250;
    828         protected static int TAG_CHECK_WARN   = 1260;
    829         protected static int TAG_CHECK_INFO   = 1270;
     826        protected static final int TAG_CHECK_ERROR  = 1250;
     827        protected static final int TAG_CHECK_WARN   = 1260;
     828        protected static final int TAG_CHECK_INFO   = 1270;
    830829
    831830        private static class CheckerElement {
  • trunk/src/org/openstreetmap/josm/data/validation/tests/UnconnectedWays.java

    r4806 r4869  
    3939public class UnconnectedWays extends Test {
    4040
    41     protected static int UNCONNECTED_WAYS = 1301;
     41    protected static final int UNCONNECTED_WAYS = 1301;
    4242    protected static final String PREFIX = ValidatorPreference.PREFIX + "." + UnconnectedWays.class.getSimpleName();
    4343
     
    314314        public boolean isArea() {
    315315            return w.hasKey("landuse")
    316             || w.hasKey("leisure")
    317             || w.hasKey("amenity")
    318             || w.hasKey("building");
     316                    || w.hasKey("leisure")
     317                    || w.hasKey("amenity")
     318                    || w.hasKey("building");
    319319        }
    320320    }
  • trunk/src/org/openstreetmap/josm/data/validation/tests/WronglyOrderedWays.java

    r4806 r4869  
    1919public class WronglyOrderedWays extends Test {
    2020
    21     protected static int WRONGLY_ORDERED_COAST = 1001;
     21    protected static final int WRONGLY_ORDERED_COAST = 1001;
    2222    //protected static int WRONGLY_ORDERED_WATER = 1002;
    23     protected static int WRONGLY_ORDERED_LAND  = 1003;
     23    protected static final int WRONGLY_ORDERED_LAND  = 1003;
    2424
    2525    /**
     
    2828    public WronglyOrderedWays() {
    2929        super(tr("Wrongly Ordered Ways"),
    30               tr("This test checks the direction of water, land and coastline ways."));
     30                tr("This test checks the direction of water, land and coastline ways."));
    3131    }
    3232
     
    3838
    3939        String natural = w.get("natural");
    40         if (natural == null) {
     40        if (natural == null)
    4141            return;
    42         } else if ("coastline".equals(natural) && Geometry.isClockwise(w)) {
     42        else if ("coastline".equals(natural) && Geometry.isClockwise(w)) {
    4343            reportError(w, tr("Reversed coastline: land not on left side"), WRONGLY_ORDERED_COAST);
    44         /*} else if ("water".equals(natural) && !Geometry.isClockwise(w)) {
     44            /*} else if ("water".equals(natural) && !Geometry.isClockwise(w)) {
    4545            reportError(w, tr("Reversed water: land not on left side"), WRONGLY_ORDERED_WATER);*/
    4646        } else if ("land".equals(natural) && Geometry.isClockwise(w)) {
    4747            reportError(w, tr("Reversed land: land not on left side"), WRONGLY_ORDERED_LAND);
    48         } else {
     48        } else
    4949            return;
    50         }
    5150
    5251    }
  • trunk/src/org/openstreetmap/josm/gui/NavigatableComponent.java

    r4627 r4869  
    6464    public static final String PROPNAME_CENTER = "center";
    6565    public static final String PROPNAME_SCALE  = "scale";
    66    
     66
    6767    /**
    6868     * the zoom listeners
     
    237237                1.0/scale, 0.0, 0.0, -1.0/scale, getWidth()/2.0 - center.east()/scale, getHeight()/2.0 + center.north()/scale);
    238238    }
    239    
     239
    240240    /**
    241241     * Return the point on the screen where this Coordinate would be.
     
    394394                        }
    395395                    }
    396             ).start();
     396                    ).start();
    397397        }
    398398    }
     
    11611161    public int getViewID() {
    11621162        String x = center.east() + "_" + center.north() + "_" + scale + "_" +
    1163         getWidth() + "_" + getHeight() + "_" + getProjection().toString();
     1163                getWidth() + "_" + getHeight() + "_" + getProjection().toString();
    11641164        java.util.zip.CRC32 id = new java.util.zip.CRC32();
    11651165        id.update(x.getBytes());
     
    12091209    public static final SystemOfMeasurement IMPERIAL_SOM = new SystemOfMeasurement(0.3048, "ft", 1609.344, "mi");
    12101210
    1211     public static Map<String, SystemOfMeasurement> SYSTEMS_OF_MEASUREMENT;
     1211    public static final Map<String, SystemOfMeasurement> SYSTEMS_OF_MEASUREMENT;
    12121212    static {
    12131213        SYSTEMS_OF_MEASUREMENT = new LinkedHashMap<String, SystemOfMeasurement>();
  • trunk/src/org/openstreetmap/josm/gui/dialogs/properties/PropertiesDialog.java

    r4773 r4869  
    171171    // hook for roadsigns plugin to display a small
    172172    // button in the upper right corner of this dialog
    173     public static JPanel pluginHook = new JPanel();
     173    public static final JPanel pluginHook = new JPanel();
    174174
    175175    private JPopupMenu propertyMenu;
     
    279279                boolean c1 = m.containsKey(o1.getValue());
    280280                boolean c2 = m.containsKey(o2.getValue());
    281                 if (c1 == c2) {
     281                if (c1 == c2)
    282282                    return String.CASE_INSENSITIVE_ORDER.compare(o1.getValue(), o2.getValue());
    283                 } else if (c1) {
     283                else if (c1)
    284284                    return -1;
    285                 } else {
     285                else
    286286                    return +1;
    287                 }
    288287            }
    289288        };
     
    10511050            for (int row : rows) {
    10521051                String key = propertyData.getValueAt(row, 0).toString();
    1053                 if (row == nextKeyIndex + 1)
     1052                if (row == nextKeyIndex + 1) {
    10541053                    nextKeyIndex = row; // no gap yet
     1054                }
    10551055                tags.put(key, null);
    10561056            }
     
    10601060            int rowCount = propertyData.getRowCount();
    10611061            if (rowCount > rows.length) {
    1062                 if (nextKeyIndex == rows[rows.length-1])
     1062                if (nextKeyIndex == rows[rows.length-1]) {
    10631063                    // no gap found, pick next or previous key in list
    10641064                    nextKeyIndex = (nextKeyIndex + 1 < rowCount ? nextKeyIndex + 1 : rows[0] - 1);
    1065                 else
     1065                } else {
    10661066                    // gap found
    10671067                    nextKeyIndex++;
     1068                }
    10681069                nextKey = (String)propertyData.getValueAt(nextKeyIndex, 0);
    10691070            }
  • trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/Marker.java

    r4804 r4869  
    167167     * stuff).
    168168     */
    169     public static List<MarkerProducers> markerProducers = new LinkedList<MarkerProducers>();
     169    public static final List<MarkerProducers> markerProducers = new LinkedList<MarkerProducers>();
    170170
    171171    // Add one Maker specifying the default behaviour.
  • trunk/src/org/openstreetmap/josm/gui/mappaint/BoxTextElemStyle.java

    r4319 r4869  
    22package org.openstreetmap.josm.gui.mappaint;
    33
    4 import java.awt.Color;
    54import static org.openstreetmap.josm.tools.Utils.equal;
    65
     6import java.awt.Color;
    77import java.awt.Rectangle;
     8
    89import org.openstreetmap.josm.data.osm.Node;
    910import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    1112import org.openstreetmap.josm.data.osm.visitor.paint.MapPainter;
    1213import org.openstreetmap.josm.data.osm.visitor.paint.PaintColors;
    13 
    1414import org.openstreetmap.josm.tools.CheckParameterUtil;
    1515
     
    2121    public enum HorizontalTextAlignment { LEFT, CENTER, RIGHT }
    2222    public enum VerticalTextAlignment { ABOVE, TOP, CENTER, BOTTOM, BELOW }
    23    
    24     public static Rectangle ZERO_BOX = new Rectangle(0, 0, 0, 0);
    25    
     23
     24    public static final Rectangle ZERO_BOX = new Rectangle(0, 0, 0, 0);
     25
    2626    public TextElement text;
    2727    public Rectangle box;
     
    3939        this.vAlign = vAlign;
    4040    }
    41    
     41
    4242    public static BoxTextElemStyle create(Environment env, Rectangle box) {
    4343        initDefaultParameters();
     
    7373            vAlign = VerticalTextAlignment.BELOW;
    7474        }
    75        
     75
    7676        return new BoxTextElemStyle(c, text, box, hAlign, vAlign);
    7777    }
    78    
     78
    7979    public static final BoxTextElemStyle SIMPLE_NODE_TEXT_ELEMSTYLE;
    8080    static {
     
    108108    @Override
    109109    public boolean equals(Object obj) {
    110         if (!super.equals(obj)) {
     110        if (!super.equals(obj))
    111111            return false;
    112         }
    113         if (obj == null || getClass() != obj.getClass()) {
     112        if (obj == null || getClass() != obj.getClass())
    114113            return false;
    115         }
    116114        final BoxTextElemStyle other = (BoxTextElemStyle) obj;
    117115        return text.equals(other.text) &&
    118                 box.equals(other.box) && 
    119                 hAlign == other.hAlign && 
     116                box.equals(other.box) &&
     117                hAlign == other.hAlign &&
    120118                vAlign == other.vAlign;
    121119    }
  • trunk/src/org/openstreetmap/josm/gui/tagging/ac/AutoCompletionItemPritority.java

    r3385 r4869  
    1515     * usually not used by the user.
    1616     */
    17     public static AutoCompletionItemPritority IS_IN_STANDARD_AND_IN_DATASET = new AutoCompletionItemPritority(true, true, false);
     17    public static final AutoCompletionItemPritority IS_IN_STANDARD_AND_IN_DATASET = new AutoCompletionItemPritority(true, true, false);
    1818
    1919    /**
     
    2121     * the value of a tag name=*.
    2222     */
    23     public static AutoCompletionItemPritority IS_IN_DATASET = new AutoCompletionItemPritority(true, false, false);
     23    public static final AutoCompletionItemPritority IS_IN_DATASET = new AutoCompletionItemPritority(true, false, false);
    2424
    2525    /**
     
    2727     * or a standard value for a given tag name (from the presets).
    2828     */
    29     public static AutoCompletionItemPritority IS_IN_STANDARD = new AutoCompletionItemPritority(false, true, false);
     29    public static final AutoCompletionItemPritority IS_IN_STANDARD = new AutoCompletionItemPritority(false, true, false);
    3030
    3131    /**
    3232     * Indicates that this is a value from a selected object.
    3333     */
    34     public static AutoCompletionItemPritority  IS_IN_SELECTION  = new AutoCompletionItemPritority(false, false, true);
     34    public static final AutoCompletionItemPritority  IS_IN_SELECTION  = new AutoCompletionItemPritority(false, false, true);
    3535
    3636    /** Unknown priority. This is the lowest priority. */
    37     public static AutoCompletionItemPritority UNKNOWN = new AutoCompletionItemPritority(false, false, false);
     37    public static final AutoCompletionItemPritority UNKNOWN = new AutoCompletionItemPritority(false, false, false);
    3838
    3939    private final boolean inDataSet;
  • trunk/src/org/openstreetmap/josm/gui/tagging/ac/AutoCompletionManager.java

    r4300 r4869  
    99import java.util.List;
    1010import java.util.Map;
     11import java.util.Map.Entry;
    1112import java.util.Set;
    12 import java.util.Map.Entry;
    1313
    1414import org.openstreetmap.josm.data.osm.DataSet;
     
    6464     * can be accessed directly
    6565     */
    66     protected static MultiMap<String, String> presetTagCache = new MultiMap<String, String>();
     66    protected static final MultiMap<String, String> presetTagCache = new MultiMap<String, String>();
    6767    /**
    6868     * the cached list of member roles
     
    7575     * can be accessed directly
    7676     */
    77     protected static Set<String> presetRoleCache = new HashSet<String>();
     77    protected static final Set<String> presetRoleCache = new HashSet<String>();
    7878
    7979    public AutoCompletionManager(DataSet ds) {
  • trunk/src/org/openstreetmap/josm/io/imagery/OsmosnimkiOffsetServer.java

    r4868 r4869  
    1616
    1717public class OsmosnimkiOffsetServer implements OffsetServer {
    18     public static StringProperty PROP_SERVER_URL = new StringProperty("imagery.offsetserver.url","http://offset.osmosnimki.ru/offset/v0?");
     18    public static final StringProperty PROP_SERVER_URL = new StringProperty("imagery.offsetserver.url","http://offset.osmosnimki.ru/offset/v0?");
    1919    private String url;
    2020
Note: See TracChangeset for help on using the changeset viewer.