Index: trunk/src/org/openstreetmap/josm/data/coor/LatLon.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/coor/LatLon.java	(revision 9860)
+++ trunk/src/org/openstreetmap/josm/data/coor/LatLon.java	(revision 9861)
@@ -205,5 +205,5 @@
 
     /**
-     * Constructs a new {@link LatLon}
+     * Constructs a new object representing the given latitude/longitude.
      * @param lat the latitude, i.e., the north-south position in degrees
      * @param lon the longitude, i.e., the east-west position in degrees
@@ -217,4 +217,8 @@
     }
 
+    /**
+     * Constructs a new object for the given coordinate
+     * @param coor the coordinate
+     */
     public LatLon(ICoordinate coor) {
         this(coor.getLat(), coor.getLon());
@@ -233,4 +237,9 @@
     public static final String NORTH = trc("compass", "N");
 
+    /**
+     * Formats the latitude part according to the given format
+     * @param d the coordinate format to use
+     * @return the formatted latitude
+     */
     public String latToString(CoordinateFormat d) {
         switch(d) {
@@ -254,4 +263,9 @@
     public static final String EAST = trc("compass", "E");
 
+    /**
+     * Formats the longitude part according to the given format
+     * @param d the coordinate format to use
+     * @return the formatted longitude
+     */
     public String lonToString(CoordinateFormat d) {
         switch(d) {
@@ -458,5 +472,7 @@
      *
      * @return rounded value
-     */
+     * @deprecated Use {@link #roundToOsmPrecision(double)} instead
+     */
+    @Deprecated
     public static double roundToOsmPrecisionStrict(double value) {
         return roundToOsmPrecision(value);
@@ -481,10 +497,9 @@
      *
      * @return a clone of this lat LatLon
-     */
+     * @deprecated Use {@link #getRoundedToOsmPrecision()} instead
+     */
+    @Deprecated
     public LatLon getRoundedToOsmPrecisionStrict() {
-        return new LatLon(
-                roundToOsmPrecisionStrict(lat()),
-                roundToOsmPrecisionStrict(lon())
-                );
+        return getRoundedToOsmPrecision();
     }
 
@@ -503,4 +518,8 @@
     }
 
+    /**
+     * Converts this latitude/longitude to an instance of {@link ICoordinate}.
+     * @return a {@link ICoordinate} instance of this latitude/longitude
+     */
     public ICoordinate toCoordinate() {
         return new org.openstreetmap.gui.jmapviewer.Coordinate(lat(), lon());
Index: trunk/test/unit/org/openstreetmap/josm/data/coor/LatLonTest.java
===================================================================
--- trunk/test/unit/org/openstreetmap/josm/data/coor/LatLonTest.java	(revision 9860)
+++ trunk/test/unit/org/openstreetmap/josm/data/coor/LatLonTest.java	(revision 9861)
@@ -4,5 +4,10 @@
 import static org.junit.Assert.assertEquals;
 
+import java.util.Locale;
+
+import org.junit.Before;
 import org.junit.Test;
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.data.projection.Projections;
 
 /**
@@ -10,4 +15,13 @@
  */
 public class LatLonTest {
+
+    /**
+     * Setup test.
+     */
+    @Before
+    public void setUp() throws Exception {
+        Locale.setDefault(Locale.GERMAN);
+        Main.setProjection(Projections.getProjectionByCode("EPSG:3857")); // Mercator
+    }
 
     private static final double EPSILON = 1e-6;
@@ -26,57 +40,57 @@
 
     /**
-     * Test of {@link LatLon#roundToOsmPrecisionStrict}
+     * Test of {@link LatLon#roundToOsmPrecision}
      */
     @Test
-    public void testRoundToOsmPrecisionStrict() {
+    public void testRoundToOsmPrecision() {
 
         for (double value : SAMPLE_VALUES) {
-            assertEquals(LatLon.roundToOsmPrecisionStrict(value), value, 0);
+            assertEquals(LatLon.roundToOsmPrecision(value), value, 0);
         }
 
-        assertEquals(LatLon.roundToOsmPrecisionStrict(0.0), 0.0, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(-0.0), 0.0, 0);
+        assertEquals(LatLon.roundToOsmPrecision(0.0), 0.0, 0);
+        assertEquals(LatLon.roundToOsmPrecision(-0.0), 0.0, 0);
 
-        assertEquals(LatLon.roundToOsmPrecisionStrict(0.12345678),  0.1234568, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(0.123456789), 0.1234568, 0);
+        assertEquals(LatLon.roundToOsmPrecision(0.12345678),  0.1234568, 0);
+        assertEquals(LatLon.roundToOsmPrecision(0.123456789), 0.1234568, 0);
 
-        assertEquals(LatLon.roundToOsmPrecisionStrict(1.12345678),  1.1234568, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(1.123456789), 1.1234568, 0);
+        assertEquals(LatLon.roundToOsmPrecision(1.12345678),  1.1234568, 0);
+        assertEquals(LatLon.roundToOsmPrecision(1.123456789), 1.1234568, 0);
 
-        assertEquals(LatLon.roundToOsmPrecisionStrict(10.12345678),  10.1234568, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(10.123456789), 10.1234568, 0);
+        assertEquals(LatLon.roundToOsmPrecision(10.12345678),  10.1234568, 0);
+        assertEquals(LatLon.roundToOsmPrecision(10.123456789), 10.1234568, 0);
 
-        assertEquals(LatLon.roundToOsmPrecisionStrict(100.12345678),  100.1234568, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(100.123456789), 100.1234568, 0);
+        assertEquals(LatLon.roundToOsmPrecision(100.12345678),  100.1234568, 0);
+        assertEquals(LatLon.roundToOsmPrecision(100.123456789), 100.1234568, 0);
 
-        assertEquals(LatLon.roundToOsmPrecisionStrict(100.00000001),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(100.000000001),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(100.0000000001),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(100.00000000001),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(100.000000000001),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(100.0000000000001),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(100.00000000000001),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(100.000000000000001),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(100.0000000000000001),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(100.00000000000000001),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(100.000000000000000001),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(100.0000000000000000001),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(100.00000000000000000001),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(100.00000001),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(100.000000001),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(100.0000000001),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(100.00000000001),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(100.000000000001),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(100.0000000000001),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(100.00000000000001),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(100.000000000000001),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(100.0000000000000001),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(100.00000000000000001),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(100.000000000000000001),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(100.0000000000000000001),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(100.00000000000000000001),  100.0000000, 0);
 
-        assertEquals(LatLon.roundToOsmPrecisionStrict(99.999999999999999999999),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(99.99999999999999999999),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(99.9999999999999999999),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(99.999999999999999999),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(99.99999999999999999),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(99.9999999999999999),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(99.999999999999999),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(99.99999999999999),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(99.9999999999999),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(99.999999999999),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(99.99999999999),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(99.9999999999),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(99.999999999),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(99.99999999),  100.0000000, 0);
-        assertEquals(LatLon.roundToOsmPrecisionStrict(99.9999999),  99.9999999, 0);
+        assertEquals(LatLon.roundToOsmPrecision(99.999999999999999999999),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(99.99999999999999999999),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(99.9999999999999999999),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(99.999999999999999999),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(99.99999999999999999),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(99.9999999999999999),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(99.999999999999999),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(99.99999999999999),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(99.9999999999999),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(99.999999999999),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(99.99999999999),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(99.9999999999),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(99.999999999),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(99.99999999),  100.0000000, 0);
+        assertEquals(LatLon.roundToOsmPrecision(99.9999999),  99.9999999, 0);
     }
 
@@ -143,3 +157,19 @@
         assertEquals(270, Math.toDegrees(e.bearing(c)), EPSILON);
     }
+
+    /**
+     * Tests the methods {@link LatLon#latToString(CoordinateFormat)}, {@link LatLon#lonToString(CoordinateFormat)}.
+     */
+    @Test
+    public void testFormatting() {
+        LatLon c = new LatLon(47.000000, 19.000000);
+        assertEquals("47.0", c.latToString(CoordinateFormat.DECIMAL_DEGREES));
+        assertEquals("19.0", c.lonToString(CoordinateFormat.DECIMAL_DEGREES));
+        assertEquals("47°00'00,0\"N", c.latToString(CoordinateFormat.DEGREES_MINUTES_SECONDS));
+        assertEquals("19°00'00,0\"E", c.lonToString(CoordinateFormat.DEGREES_MINUTES_SECONDS));
+        assertEquals("47°00,000'N", c.latToString(CoordinateFormat.NAUTICAL));
+        assertEquals("19°00,000'E", c.lonToString(CoordinateFormat.NAUTICAL));
+        assertEquals("5942074.0724311", c.latToString(CoordinateFormat.EAST_NORTH));
+        assertEquals("2115070.3250722", c.lonToString(CoordinateFormat.EAST_NORTH));
+    }
 }
