source: osm/applications/editors/josm/plugins/wms-turbo-challenge2/src/wmsturbochallenge/FakeMapView.java@ 19990

/*
 * GPLv2 or 3, Copyright (c) 2010  Andrzej Zaborowski
 *
 * Implements a fake MapView that we can pass to WMSLayer's .paint,
 * this will give us two things:
 *  # We'll be able to tell WMSLayer.paint() what area we want it
 *    to download (it ignores the "bounds" parameter) and override
 *    isVisible and friends as needed, and
 *  # We'll receive notifications from Grabber when we need to
 *    repaint (and call WMSLayer's .paint again) because the
 *    Grabber downloaded some or all of the tiles that we asked
 *    WMSLayer for and WMSLayer created the Grabber passing it
 *    our MapView.  Otherwise we wouldn't be able to tell when
 *    this happened and could only guess.
 */
package wmsturbochallenge;

import org.openstreetmap.josm.gui.MapView;
import org.openstreetmap.josm.data.ProjectionBounds;
import org.openstreetmap.josm.data.coor.EastNorth;

import java.awt.Point;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;

class fake_map_view extends MapView {
        public ProjectionBounds view_bounds;
        public MapView parent;

        public Graphics2D graphics;
        public BufferedImage ground_image;
        public int ground_width = -1;
        public int ground_height = -1;
        public double scale;
        public double max_east_west;

        public fake_map_view(MapView parent, double scale) {
                this.parent = parent;
                this.scale = scale;

                ProjectionBounds parent_bounds = parent.getProjectionBounds();
                max_east_west =
                        parent_bounds.max.east() - parent_bounds.min.east();
        }

        public void setProjectionBounds(ProjectionBounds bounds) {
                view_bounds = bounds;

                if (bounds.max.east() - bounds.min.east() > max_east_west) {
                        max_east_west = bounds.max.east() - bounds.min.east();

                        /* We need to set the parent MapView's bounds (i.e.
                         * zoom level) to the same as ours max possible
                         * bounds to avoid WMSLayer thinking we're zoomed
                         * out more than we are or it'll pop up an annoying
                         * "requested area is too large" popup.
                         */
                        EastNorth parent_center = parent.getCenter();
                        parent.zoomTo(new ProjectionBounds(
                                        new EastNorth(
                                                parent_center.east() -
                                                max_east_west / 2,
                                                parent_center.north()),
                                        new EastNorth(
                                                parent_center.east() +
                                                max_east_west / 2,
                                                parent_center.north())));

                        /* Request again because NavigatableContent adds
                         * a border just to be sure.
                         */
                        ProjectionBounds new_bounds =
                                parent.getProjectionBounds();
                        max_east_west =
                                new_bounds.max.east() - new_bounds.min.east();
                }

                Point vmin = getPoint(bounds.min);
                Point vmax = getPoint(bounds.max);
                int w = vmax.x + 1;
                int h = vmin.y + 1;

                if (w <= ground_width && h <= ground_height) {
                        graphics.setClip(0, 0, w, h);
                        return;
                }

                if (w > ground_width)
                        ground_width = w;
                if (h > ground_height)
                        ground_height = h;

                ground_image = new BufferedImage(ground_width,
                                ground_height,
                                BufferedImage.TYPE_INT_RGB);
                graphics = ground_image.createGraphics();
                graphics.setClip(0, 0, w, h);
        }

        public ProjectionBounds getProjectionBounds() {
                return view_bounds;
        }

        public Point getPoint(EastNorth p) {
                double x = p.east() - view_bounds.min.east();
                double y = view_bounds.max.north() - p.north();
                x /= this.scale;
                y /= this.scale;

                return new Point((int) x, (int) y);
        }

        public EastNorth getEastNorth(int x, int y) {
                return new EastNorth(
                        view_bounds.min.east() + x * this.scale,
                        view_bounds.min.north() - y * this.scale);
        }

        public boolean isVisible(int x, int y) {
                return true;
        }

        public Graphics getGraphics() {
                return graphics;
        }

        public void repaint() {
        }
}