Changeset 10375 in josm for trunk/src/org/openstreetmap/josm/gui/MapViewState.java

Timestamp:

2016-06-14T19:46:27+02:00 (8 years ago)

Author:

Don-vip

Message:

fix #12959 - Move state changes to MapViewState class (patch by michael2402) - gscore-core + checkstyle fixes

File:

• trunk/src/org/openstreetmap/josm/gui/MapViewState.java (modified) (8 diffs)

trunk/src/org/openstreetmap/josm/gui/MapViewState.java

@@ -2 +2 @@
 package org.openstreetmap.josm.gui;
 
+import java.awt.Container;
 import java.awt.Point;
+import java.awt.geom.AffineTransform;
 import java.awt.geom.Point2D;
 import java.awt.geom.Point2D.Double;
 
-import javax.swing.SwingUtilities;
+import javax.swing.JComponent;
 
 import org.openstreetmap.josm.Main;
@@ -14 +16 @@
 import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.projection.Projection;
+import org.openstreetmap.josm.gui.download.DownloadDialog;
 
 /**
@@ -20 +23 @@
  * @since 10343
  */
-public class MapViewState {
-
-    private final Projection projection = Main.getProjection();
+public final class MapViewState {
+
+    private final Projection projection;
 
     private final int viewWidth;
@@ -34 +37 @@
     private final EastNorth topLeft;
 
-    private final NavigatableComponent navigatableComponent;
-
-    /**
-     * Create a new {@link MapViewState} object for the given map view.
-     * @param navigatableComponent The view.
-     */
-    public MapViewState(NavigatableComponent navigatableComponent) {
-        this.navigatableComponent = navigatableComponent;
-        viewWidth = navigatableComponent.getWidth();
-        viewHeight = navigatableComponent.getHeight();
-
-        scale = navigatableComponent.getScale();
-        EastNorth center = navigatableComponent.getCenter();
-        topLeft = new EastNorth(center.east() - viewWidth / 2.0 * scale, center.north() + viewHeight / 2.0 * scale);
+    private final Point topLeftOnScreen;
+    private final Point topLeftInWindow;
+
+    /**
+     * Create a new {@link MapViewState}
+     * @param projection The projection to use.
+     * @param viewWidth The view width
+     * @param viewHeight The view height
+     * @param scale The scale to use
+     * @param topLeft The top left corner in east/north space.
+     */
+    private MapViewState(Projection projection, int viewWidth, int viewHeight, double scale, EastNorth topLeft) {
+        this.projection = projection;
+        this.scale = scale;
+        this.topLeft = topLeft;
+
+        this.viewWidth = viewWidth;
+        this.viewHeight = viewHeight;
+        topLeftInWindow = new Point(0, 0);
+        topLeftOnScreen = new Point(0, 0);
+    }
+
+    private MapViewState(EastNorth topLeft, MapViewState mapViewState) {
+        this.projection = mapViewState.projection;
+        this.scale = mapViewState.scale;
+        this.topLeft = topLeft;
+
+        viewWidth = mapViewState.viewWidth;
+        viewHeight = mapViewState.viewHeight;
+        topLeftInWindow = mapViewState.topLeftInWindow;
+        topLeftOnScreen = mapViewState.topLeftOnScreen;
+    }
+
+    private MapViewState(double scale, MapViewState mapViewState) {
+        this.projection = mapViewState.projection;
+        this.scale = scale;
+        this.topLeft = mapViewState.topLeft;
+
+        viewWidth = mapViewState.viewWidth;
+        viewHeight = mapViewState.viewHeight;
+        topLeftInWindow = mapViewState.topLeftInWindow;
+        topLeftOnScreen = mapViewState.topLeftOnScreen;
+    }
+
+    private MapViewState(JComponent position, MapViewState mapViewState) {
+        this.projection = mapViewState.projection;
+        this.scale = mapViewState.scale;
+        this.topLeft = mapViewState.topLeft;
+
+        viewWidth = position.getWidth();
+        viewHeight = position.getHeight();
+        topLeftInWindow = new Point();
+        // better than using swing utils, since this allows us to use the mehtod if no screen is present.
+        Container component = position;
+        while (component != null) {
+            topLeftInWindow.x += component.getX();
+            topLeftInWindow.y += component.getY();
+            component = component.getParent();
+        }
+        topLeftOnScreen = position.getLocationOnScreen();
+    }
+
+    /**
+     * The scale in east/north units per pixel.
+     * @return The scale.
+     */
+    public double getScale() {
+        return scale;
     }
 
@@ -110 +167 @@
 
     /**
+     * Creates an affine transform that is used to convert the east/north coordinates to view coordinates.
+     * @return The affine transform. It should not be changed.
+     * @since xxx
+     */
+    public AffineTransform getAffineTransform() {
+        return new AffineTransform(1.0 / scale, 0.0, 0.0, -1.0 / scale, topLeft.east() / scale,
+                topLeft.north() / scale);
+    }
+
+    /**
+     * Creates a new state that is the same as the current state except for that it is using a new center.
+     * @param newCenter The new center coordinate.
+     * @return The new state.
+     * @since xxx
+     */
+    public MapViewState usingCenter(EastNorth newCenter) {
+        return movedTo(getCenter(), newCenter);
+    }
+
+    /**
+     * @param mapViewPoint The reference point.
+     * @param newEastNorthThere The east/north coordinate that should be there.
+     * @return The new state.
+     * @since xxx
+     */
+    public MapViewState movedTo(MapViewPoint mapViewPoint, EastNorth newEastNorthThere) {
+        EastNorth delta = newEastNorthThere.subtract(mapViewPoint.getEastNorth());
+        if (delta.distanceSq(0, 0) < .000001) {
+            return this;
+        } else {
+            return new MapViewState(topLeft.add(delta), this);
+        }
+    }
+
+    /**
+     * Creates a new state that is the same as the current state except for that it is using a new scale.
+     * @param newScale The new scale to use.
+     * @return The new state.
+     * @since xxx
+     */
+    public MapViewState usingScale(double newScale) {
+        return new MapViewState(newScale, this);
+    }
+
+    /**
+     * Creates a new state that is the same as the current state except for that it is using the location of the given component.
+     * <p>
+     * The view is moved so that the center is the same as the old center.
+     * @param positon The new location to use.
+     * @return The new state.
+     * @since xxx
+     */
+    public MapViewState usingLocation(JComponent positon) {
+        EastNorth center = this.getCenter().getEastNorth();
+        return new MapViewState(positon, this).usingCenter(center);
+    }
+
+    /**
+     * Create the default {@link MapViewState} object for the given map view. The screen position won't be set so that this method can be used
+     * before the view was added to the hirarchy.
+     * @param width The view width
+     * @param height The view height
+     * @return The state
+     * @since xxx
+     */
+    public static MapViewState createDefaultState(int width, int height) {
+        Projection projection = Main.getProjection();
+        double scale = projection.getDefaultZoomInPPD();
+        MapViewState state = new MapViewState(projection, width, height, scale, new EastNorth(0, 0));
+        EastNorth center = calculateDefaultCenter();
+        return state.movedTo(state.getCenter(), center);
+    }
+
+    private static EastNorth calculateDefaultCenter() {
+        Bounds b = DownloadDialog.getSavedDownloadBounds();
+        if (b == null) {
+            b = Main.getProjection().getWorldBoundsLatLon();
+        }
+        return Main.getProjection().latlon2eastNorth(b.getCenter());
+    }
+
+    /**
      * A class representing a point in the map view. It allows to convert between the different coordinate systems.
      * @author Michael Zangl
@@ -132 +271 @@
          */
         public Point2D getInWindow() {
-            Point corner = SwingUtilities.convertPoint(navigatableComponent, new Point(0, 0), null);
-            return getUsingCorner(corner);
+            return getUsingCorner(topLeftInWindow);
         }
 
@@ -141 +279 @@
          */
         public Point2D getOnScreen() {
-            Point corner = new Point(0, 0);
-            SwingUtilities.convertPointToScreen(corner, navigatableComponent);
-            return getUsingCorner(corner);
+            return getUsingCorner(topLeftOnScreen);
         }
 
@@ -268 +404 @@
         }
     }
+
 }