skrueger/geotools/XMapPane.java

package skrueger.geotools;

import java.awt.Color;
import java.awt.Cursor;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.awt.event.InputEvent;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.geom.AffineTransform;
import java.awt.geom.NoninvertibleTransformException;
import java.awt.geom.Point2D;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;

import javax.swing.Timer;

import org.apache.log4j.Logger;
import org.geotools.feature.FeatureCollection;
import org.geotools.geometry.Envelope2D;
import org.geotools.geometry.jts.JTS;
import org.geotools.geometry.jts.ReferencedEnvelope;
import org.geotools.map.DefaultMapContext;
import org.geotools.map.MapContext;
import org.geotools.map.MapLayer;
import org.geotools.map.event.MapLayerEvent;
import org.geotools.map.event.MapLayerListEvent;
import org.geotools.map.event.MapLayerListListener;
import org.geotools.map.event.MapLayerListener;
import org.geotools.referencing.CRS;
import org.geotools.renderer.GTRenderer;
import org.geotools.renderer.label.LabelCacheImpl;
import org.geotools.renderer.lite.LabelCache;
import org.geotools.renderer.lite.RendererUtilities;
import org.geotools.renderer.lite.StreamingRenderer;
import org.geotools.swing.JMapPane;
import org.geotools.swing.event.MapMouseEvent;
import org.geotools.swing.event.MapPaneEvent;
import org.geotools.swing.event.MapPaneListener;
import org.opengis.feature.simple.SimpleFeature;
import org.opengis.feature.simple.SimpleFeatureType;
import org.opengis.referencing.FactoryException;
import org.opengis.referencing.crs.CoordinateReferenceSystem;
import org.opengis.referencing.operation.MathTransform;
import org.opengis.referencing.operation.TransformException;

import schmitzm.geotools.GTUtil;
import schmitzm.geotools.JTSUtil;
import schmitzm.geotools.gui.SelectableXMapPane;
import schmitzm.geotools.io.GeoImportUtil;
import schmitzm.geotools.map.event.JMapPaneListener;
import schmitzm.geotools.map.event.MapLayerAdapter;
import schmitzm.lang.LangUtil;
import schmitzm.swing.JPanel;
import schmitzm.swing.SwingUtil;

import com.vividsolutions.jts.geom.Coordinate;
import com.vividsolutions.jts.geom.Envelope;
import com.vividsolutions.jts.geom.Geometry;

/**
 * The {@link XMapPane} class uses a Geotools {@link GTRenderer} to paint up to
 * two {@link MapContext}s: a "local" {@link MapContext} and a "background"
 * {@link MapContext}. The idea is, that rendering a background layer made up of
 * e.g. OSM data, may take much longer than rendering local data.<br>
 * Every {@link MapContext} is rendered on a {@link Thread} of it's own.
 * Starting/ cancelling these threads is done by the {@link RenderingExecutor}.<br>
 * <br>
 * While the renderers are rending the map, a <br>
 * The {@link XMapPane} is based on schmitzm {@link JPanel}, so
 * {@link #print(Graphics)} will automatically set the background of components
 * to pure white.
 * 
 * The XMapPane has a {@link MouseListener} that manages zooming.<br>
 * A logo/icon to float in the lower left corner may be set with
 * {@link #setMapImage(BufferedImage)}<br>
 * 
 * @see SelectableXMapPane - an extension of {@link XMapPane} that supports
 *      selecting features.
 * 
 * @author stefan
 * 
 */
public class XMapPane extends JPanel {

        private static final int IMAGETYPE = BufferedImage.TYPE_INT_RGB;
        private static final int IMAGETYPE_withAlpha = BufferedImage.TYPE_INT_ARGB;

        private static Logger LOGGER = Logger.getLogger(XMapPane.class);

        private boolean acceptsRepaintCalls = true;

        /**
         * Main {@link MapContext} that holds all layers that are rendered into the
         * {@link #localImage} by the {@link #localRenderer}
         */
        MapContext localContext;

        /**
         * {@link MapContext} holding the background layers. Use it for layers that
         * CAN take very long for rendering, like layer from the Internet: WMS, WFS,
         * OSM...<br>
         * <code>null</code> by default.
         * 
         * @see #setBgContext(MapContext)
         * @see #getBgContext()
         */
        MapContext bgContext;

        /**
         * While threads are working, calls {@link XMapPane#updateFinalImage()}
         * regularly and {@link #repaint()}. This {@link Timer} is stopped when all
         * renderers have finished.
         * 
         * @see #INITIAL_REPAINT_DELAYAL
         * @see #REPEATING_REPAINT_DELAY
         */
        final private Timer repaintTimer;

        /**
         * The initial delay in milliseconds until the {@link #finalImage} is
         * updated the first time.
         */
        public static final int INITIAL_REPAINT_DELAY = 1000;

        /**
         * While the {@link #bgExecuter} and {@link #localExecuter} are rendering,
         * the {@link #repaintTimer} is regularly updating the {@link #finalImage}
         * with previews.
         */
        public static final long REPEATING_REPAINT_DELAY = 500;

        /**
         * Default delay (milliseconds) before the map will be redrawn when resizing
         * the pane. This is to avoid flickering while drag-resizing.
         */
        public static final int DEFAULT_RESIZING_PAINT_DELAY = 600;

        public static final int NONE = -123;

        /**
         * Flag fuer Modus "Kartenausschnitt bewegen". Nicht fuer Window-Auswahl
         * moeglich!
         * 
         * @see #setState(int)
         */
        public static final int PAN = 1;

        /**
         * Flag fuer Modus "SimpleFeature-Auswahl auf allen (sichtbaren) Layern".
         * 
         * @see #setState(int)
         * @see #setState(int)
         */
        public static final int SELECT_ALL = 103;
        /**
         * Flag fuer Modus
         * "Auswahl nur eines Features, das erste sichtbare von Oben".
         * 
         * @see #setState(int)
         * @see #setState(int)
         */
        public static final int SELECT_ONE_FROM_TOP = 104;
        /**
         * Flag fuer Modus
         * "SimpleFeature-Auswahl auf dem obersten (sichtbaren) Layer".
         * 
         * @see #setState(int)
         * @see #setState(int)
         */
        public static final int SELECT_TOP = 4;

        public static final Cursor WAIT_CURSOR = Cursor
                        .getPredefinedCursor(Cursor.WAIT_CURSOR);

        final static Font waitFont = new Font("Arial", Font.BOLD, 30);
        final String waitMsg = SwingUtil.R("WaitMess");
        final static Font errorFont = new Font("Arial", Font.BOLD, 13);

        /**
         * Flag fuer Modus "Heran zoomen".
         * 
         * @see #setState(int)
         * @see #setState(int)
         */
        public static final int ZOOM_IN = 2;

        /**
         * Flag fuer Modus "Heraus zoomen". Nicht fuer Window-Auswahl moeglich!
         * 
         * @see #setState(int)
         */
        public static final int ZOOM_OUT = 3;

        /**
         * Konvertiert die Maus-Koordinaten (relativ zum <code>JMapPane</code>) in
         * Karten-Koordinaten.
         * 
         * @param e
         *            Maus-Ereignis
         */
        public static Point2D getMapCoordinatesFromEvent(final MouseEvent e) {
                // aktuelle Geo-Position aus GeoMouseEvent ermitteln
                if (e != null && e instanceof MapMouseEvent)
                        try {
                                return ((MapMouseEvent) e).getMapPosition().toPoint2D();
                        } catch (final Exception err) {
                                LOGGER
                                                .error(
                                                                "return ((GeoMouseEvent) e).getMapCoordinate(null).toPoint2D();",
                                                                err);
                        }

                // aktuelle Geo-Position ueber Transformation des JMapPane berechnen
                if (e != null && e.getSource() instanceof XMapPane) {

                        final XMapPane xMapPane = (XMapPane) e.getSource();

                        if (!xMapPane.isWellDefined())
                                return null;

                        final AffineTransform at = xMapPane.getScreenToWorld();
                        if (at != null)
                                return at.transform(e.getPoint(), null);
                        return null;
                }
                throw new IllegalArgumentException(
                                "MouseEvent has to be of instance MapMouseEvent or come from an XMapPane");
        }

        /**
         * Listens to changes of the "background" {@link MapContext} and triggers
         * repaints where needed.
         */
        private final MapLayerListListener bgContextListener = new MapLayerListListener() {

                @Override
                public void layerAdded(final MapLayerListEvent event) {

                        MapLayer layer = event.getLayer();

                        layer.addMapLayerListener(bgMapLayerListener);

                        if (localContext.getLayers().length == 0
                                        && bgContext.getLayers().length == 1) { // the first one and
                                // localContext is
                                // empty
                                if (!setMapArea(localContext.getAreaOfInterest()))
                                        requestStartRendering();
                                return;
                        }

                        // We need to redraw, even in case that the mapArea didn't change
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();

                }

                @Override
                public void layerChanged(final MapLayerListEvent event) {
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();
                }

                @Override
                public void layerMoved(final MapLayerListEvent event) {
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();
                }

                @Override
                public void layerRemoved(final MapLayerListEvent event) {
                        if (event.getLayer() != null)
                                event.getLayer().removeMapLayerListener(bgMapLayerListener);
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();
                }
        };

        /**
         * compass and icon are rendered into this image
         */
        // protected BufferedImage gadgetsImage;

        protected RenderingExecutor bgExecuter;

        /**
         * The Renderer for the LocalLayers uses this Image. When set to null,
         * please dispose this {@link Graphics2D}
         */
        private BufferedImage localImage;

        private BufferedImage finalImage;
        /**
         * If # {@link #bgExecuter} is using {@link #bgRenderer} for the Background
         * uses this Image. When set to null, please dispose the {@link Graphics2D}
         */
        private BufferedImage bgImage;

        /**
         * Optionally a transparent image to paint over the map in the lower right
         * corner.
         * 
         * @see #addGadgets(Graphics2D)
         * @see #setMapImage(BufferedImage)
         **/
        private BufferedImage mapImage = null;

        /**
         * Listens to each layer in the local {@link MapContext} for changes and
         * triggers repaints.
         */
        protected MapLayerListener bgMapLayerListener = new MapLayerAdapter() {

                @Override
                public void layerChanged(final MapLayerEvent event) {
                        // Change of SLD for example
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();
                }

                @Override
                public void layerHidden(final MapLayerEvent event) {
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();
                }

                @Override
                public void layerShown(final MapLayerEvent event) {
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();
                }
        };

        /**
         * A flag indicating if dispose() was already called. If true, then further
         * use of this {@link SelectableXMapPane} is undefined.
         */
        private boolean disposed = false;

        /**
         * While dragging, the {@link #updateFinalImage()} method is translating the
         * cached images while setting it together.
         **/
        Point imageOrigin = new Point(0, 0);
        /**
         * For every rendering thread started,
         * {@link GTUtil#createGTRenderer(MapContext)} is called to create a new
         * renderer. These Java2D rendering hints are passed to the
         * {@link GTRenderer}. The java2dHints are the same for all renderers (bg
         * and local).
         */
        private RenderingHints java2dHints;

        protected LabelCache labelCache = new LabelCacheImpl();

        /**
         * Listens to changes of the "local" {@link MapContext} and triggers
         * repaints where needed.
         */
        private final MapLayerListListener localContextListener = new MapLayerListListener() {

                @Override
                public void layerAdded(final MapLayerListEvent event) {
                        event.getLayer().addMapLayerListener(localMapLayerListener);

                        localRenderer.setContext(getContext());

                        if (localContext.getLayers().length == 1) { // the first one

                                // if the Area of Interest is unset, the LayerBounds are used
                                if (!setMapArea(localContext.getAreaOfInterest()))
                                        repaint();

                                return;
                        }

                        // We need to redraw, even in case that the mapArea didn't change
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();

                }

                @Override
                public void layerChanged(final MapLayerListEvent event) {
                        // mapImageInvalid = true;
                        // repaint();
                        localRenderer.setContext(getContext());
                        requestStartRendering();
                }

                @Override
                public void layerMoved(final MapLayerListEvent event) {
                        // mapImageInvalid = true;
                        // repaint();
                        localRenderer.setContext(getContext());
                        requestStartRendering();
                }

                @Override
                public void layerRemoved(final MapLayerListEvent event) {
                        if (event.getLayer() != null)
                                event.getLayer().removeMapLayerListener(localMapLayerListener);
                        // mapImageInvalid = true;
                        // repaint();
                        localRenderer.setContext(getContext());
                        requestStartRendering();
                }
        };

        private final RenderingExecutor localExecuter = new RenderingExecutor(this);

        /**
         * Listens to each layer in the local {@link MapContext} for changes and
         * triggers repaints.
         */
        protected MapLayerListener localMapLayerListener = new MapLayerAdapter() {

                @Override
                public void layerChanged(final MapLayerEvent event) {
                        localRenderer.setContext(getContext()); // betters for SLD changes?!
                        // Change of SLD for example
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();
                }

                @Override
                public void layerHidden(final MapLayerEvent event) {
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();
                }

                @Override
                public void layerShown(final MapLayerEvent event) {
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();
                }
        };

        private final GTRenderer localRenderer = GTUtil.createGTRenderer();

        private final GTRenderer bgRenderer = GTUtil.createGTRenderer();

        /**
         * the area of the map to draw
         */
        protected Envelope mapArea = null;

        /**
         * A flag set it {@link #setMapArea(Envelope)} to indicated the
         * {@link #paintComponent(Graphics)} method, that the image on-screen is
         * associated with {@link #oldMapArea} and may hence be scaled for a quick
         * preview.<br>
         * The flag is reset
         **/
        private boolean mapAreaChanged = false;

        /**
         * This color is used as the default background color when painting a map.
         */
        private Color mapBackgroundColor = Color.WHITE;

        /**
         * A flag indicating that the shown image is invalid and needs to be
         * re-rendered.
         */
        protected boolean mapImageInvalid = true;

        /**
         * Holds a flag for each layer, whether it is regarded or ignored on
         * {@link #SELECT_TOP}, {@link #SELECT_ALL} and {@link #SELECT_ONE_FROM_TOP}
         * actions.
         */
        final protected HashMap<MapLayer, Boolean> mapLayerSelectable = new HashMap<MapLayer, Boolean>();

        /**
         * List of listeners of this {@link XMapPane}
         */
        protected Vector<JMapPaneListener> mapPaneListeners = new Vector<JMapPaneListener>();
        /**
         * If not <code>null</code>, the {@link XMapPane} will not allow to zoom/pan
         * out of that area
         **/
        private Envelope maxExtend = null;
        private Double maxZoomScale = Double.MIN_VALUE;

        private Double minZoomScale = Double.MAX_VALUE;

        /**
         * We store the old mapArea for a moment to use it for the
         * "quick scaled preview" in case of ZoomOut
         **/
        protected Envelope oldMapArea = null;

        /**
         * We store the old transform for a moment to use it for the
         * "quick scaled preview" in case of ZoomIn
         **/
        protected AffineTransform oldScreenToWorld = null;

        /**
         * A flag indicating, that the image size has changed and the buffered
         * images are not big enough any more
         **/
        protected boolean paneResized = false;

        private BufferedImage preFinalImage;

        // if null, no quick preview will be shown
        private int quickPreviewHint = 0;

        private Map<Object, Object> rendererHints = GTUtil
                        .getDefaultGTRendererHints(localRenderer);

        private volatile Boolean requestStartRendering = false;

        private final Timer resizeTimer;

        /**
         * Transformation zwischen Fenster-Koordinaten und Karten-Koordinaten
         * (lat/lon)
         */
        protected AffineTransform screenToWorld = null;

        /**
         * The flag {@link #requestStartRendering} can be set to true by events.
         * This {@link Timer} checks the flag regularly and starts one renderer
         * thread.
         */
        final private Timer startRenderThreadsTimer;

        /**
         * The default state is ZOOM_IN, hence by default the
         * {@link #zoomMapPaneMouseListener} is also enabled.
         **/
        private int state = ZOOM_IN;

        /**
         * Manuell gesetzter statischer Cursor, unabhaengig von der aktuellen
         * MapPane-Funktion
         */
        protected Cursor staticCursor = null;

        private AffineTransform worldToScreen;

        /**
         * This {@link MouseListener} is managing all zoom related tasks
         */
        public final ZoomXMapPaneMouseListener zoomMapPaneMouseListener = new ZoomXMapPaneMouseListener(
                        this);

        /** Is set if a renderer has an error **/
        protected ArrayList<Exception> renderingErrors = new ArrayList<Exception>();

        // TODO doku
        public XMapPane() {
                this(null, null);
        }

        /**
         * full constructor extending JPanel
         * 
         * @param rendererHints
         * 
         * @param layout
         *            - layout (probably shouldn't be set)
         * @param isDoubleBuffered
         *            - a Swing thing I don't really understand
         * @param render
         *            - what to draw the map with
         * @param localContext
         *            - {@link MapContext} of layer to render.
         */
        public XMapPane(final MapContext localContext_,
                        final Map<Object, Object> rendererHints) {
                super(true);

                setRendererHints(rendererHints);

                setOpaque(true);

                if (localContext_ != null)
                        setLocalContext(localContext_);

                /**
                 * Adding the #zoomMapPaneMouseListener
                 */
                this.addMouseListener(zoomMapPaneMouseListener);
                this.addMouseMotionListener(zoomMapPaneMouseListener);
                this.addMouseWheelListener(zoomMapPaneMouseListener);

                /*
                 * We use a Timer object to avoid rendering delays and flickering when
                 * the user is drag-resizing the parent container of this map pane.
                 * 
                 * Using a ComponentListener doesn't work because, unlike a JFrame, the
                 * pane receives a stream of events during drag-resizing.
                 */
                resizeTimer = new Timer(DEFAULT_RESIZING_PAINT_DELAY, new ActionListener() {

                        public void actionPerformed(final ActionEvent e) {
                                paneResized = true;

                                if (!isWellDefined())
                                        return;

                                final Rectangle bounds = getVisibleRect();

                                final Envelope geoMapArea = tranformWindowToGeo(bounds.x,
                                                bounds.y, bounds.x + bounds.width, bounds.y
                                                                + bounds.height);

                                setMapArea(bestAllowedMapArea(geoMapArea));
                        }
                });
                resizeTimer.setRepeats(false);
                this.addComponentListener(new ComponentAdapter() {

                        @Override
                        public void componentResized(final ComponentEvent e) {
                                if (bgExecuter != null)
                                        bgExecuter.cancelTask();
                                if (localExecuter != null)
                                        localExecuter.cancelTask();
                                resizeTimer.restart();
                        }

                });

                /*
                 * Setting up the repaintTimer. Not started automatically.
                 */
                repaintTimer = new Timer((int) REPEATING_REPAINT_DELAY,
                                new ActionListener() {

                                        @Override
                                        public void actionPerformed(final ActionEvent e) {
                                                updateFinalImage();
                                                XMapPane.this.repaint();
                                        }
                                });
                repaintTimer.setInitialDelay(INITIAL_REPAINT_DELAY);
                repaintTimer.setRepeats(true);

                /*
                 * Setting up the startRenderThreadsTimer. This Timer starts
                 * automatically.
                 */
                startRenderThreadsTimer = new Timer(100, new ActionListener() {

                        @Override
                        public void actionPerformed(final ActionEvent e) {
                                synchronized (requestStartRendering) {
                                        if (requestStartRendering && isWellDefined()) {

                                                if (localExecuter.isRunning()) {
                                                        localExecuter.cancelTask();
                                                } else {
                                                        requestStartRendering = false;
                                                        startRendering();
                                                }
                                        }
                                }
                        }
                });
                startRenderThreadsTimer.start();

        }

        /**
         * Fuegt der Map einen Listener hinzu.
         * 
         * @param l
         *            neuer Listener
         */
        public void addMapPaneListener(final JMapPaneListener l) {
                mapPaneListeners.add(l);
        }

        /**
         * Korrigiert den {@link Envelope} aka {@code mapArea} auf die beste
         * erlaubte Flaeche damit die Massstabsbeschaenkungen noch eingehalten
         * werden, FALLS der uebergeben Envelope nicht schon gueltig sein sollte.<br>
         * Since 21. April 09: Before thecalculation starts, the aspect ratio is
         * corrected. This change implies, that setMapArea() will most of the time
         * not allow setting to a wrong aspectRatio.
         * 
         * @author <a href="mailto:[email protected]">Stefan Alfons
         *         Kr&uuml;ger</a>
         */
        public Envelope bestAllowedMapArea(Envelope env) {
                // return env;
                if (getWidth() == 0)
                        return env;
                if (env == null)
                        return null;

                Envelope newArea = null;

                /**
                 * Correct the aspect Ratio before we check the rest. Otherwise we might
                 * easily fail. We allow to grow here, because we don't check against
                 * the maxExtend
                 */
                final Rectangle curPaintArea = getVisibleRect();

                env = JTSUtil.fixAspectRatio(curPaintArea, env, true);

                final double scale = env.getWidth() / getWidth();
                final double centerX = env.getMinX() + env.getWidth() / 2.;
                final double centerY = env.getMinY() + env.getHeight() / 2.;
                double newWidth2 = 0;
                double newHeight2 = 0;
                if (scale < getMaxZoomScale()) {
                        // ****************************************************************************
                        // Wir zoomen weiter rein als erlaubt => Anpassen des envelope
                        // ****************************************************************************
                        newWidth2 = getMaxZoomScale() * getWidth() / 2.;
                        newHeight2 = getMaxZoomScale() * getHeight() / 2.;
                } else if (scale > getMinZoomScale()) {
                        // ****************************************************************************
                        // Wir zoomen weiter raus als erlaubt => Anpassen des envelope
                        // ****************************************************************************
                        newWidth2 = getMinZoomScale() * getWidth() / 2.;
                        newHeight2 = getMinZoomScale() * getHeight() / 2.;
                } else {
                        // ****************************************************************************
                        // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen
                        // ****************************************************************************
                        newArea = env;
                }

                if (newArea == null) {

                        final Coordinate ll = new Coordinate(centerX - newWidth2, centerY
                                        - newHeight2);
                        final Coordinate ur = new Coordinate(centerX + newWidth2, centerY
                                        + newHeight2);

                        newArea = new Envelope(ll, ur);
                }

                final Envelope maxAllowedExtend = getMaxExtend();
                while (maxAllowedExtend != null && !maxAllowedExtend.contains(newArea)
                                && newArea != null && !newArea.isNull()
                                && !Double.isNaN(newArea.getMinX())
                                && !Double.isNaN(newArea.getMaxX())
                                && !Double.isNaN(newArea.getMinY())
                                && !Double.isNaN(newArea.getMaxY())) {
                        /*
                         * If a maxExtend is set, we have to honour that...
                         */

                        // Exceeds top? Move down and maybe cut
                        if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
                                final double divY = newArea.getMaxY()
                                                - maxAllowedExtend.getMaxY();
                                // LOGGER.debug("Moving area down by " + divY);

                                newArea = new Envelope(new Coordinate(newArea.getMinX(),
                                                newArea.getMinY() - divY), new Coordinate(newArea
                                                .getMaxX(), newArea.getMaxY() - divY));

                                if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
                                        // LOGGER.debug("Now it exeeds the bottom border.. cut!");
                                        // And cut the bottom if it moved out of the area
                                        newArea = new Envelope(new Coordinate(newArea.getMinX(),
                                                        maxAllowedExtend.getMinY()), new Coordinate(newArea
                                                        .getMaxX(), newArea.getMaxY()));

                                        // LOGGER.debug("and fix aspect ratio");

                                        newArea = JTSUtil.fixAspectRatio(getVisibleRect(), newArea,
                                                        false);
                                }
                        }

                        // Exceeds bottom? Move up and maybe cut
                        if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
                                final double divY = newArea.getMinY()
                                                - maxAllowedExtend.getMinY();
                                // LOGGER.debug("Moving area up by " + divY);

                                newArea = new Envelope(new Coordinate(newArea.getMinX(),
                                                newArea.getMinY() - divY), new Coordinate(newArea
                                                .getMaxX(), newArea.getMaxY() - divY));

                                if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
                                        // LOGGER.debug("Now it exeeds the top border.. cut!");
                                        // And cut the bottom if it moved out of the area
                                        newArea = new Envelope(new Coordinate(newArea.getMinX(),
                                                        newArea.getMinY()), new Coordinate(newArea
                                                        .getMaxX(), maxAllowedExtend.getMaxY()));

                                        // LOGGER.debug("and fix aspect ratio");

                                        newArea = JTSUtil.fixAspectRatio(getVisibleRect(), newArea,
                                                        false);
                                }
                        }

                        // Exceeds to the right? move and maybe cut
                        if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {

                                // Move left..
                                final double divX = newArea.getMaxX()
                                                - maxAllowedExtend.getMaxX();
                                // LOGGER.debug("Moving area left by " + divX);

                                newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
                                                newArea.getMinY()), new Coordinate(newArea.getMaxX()
                                                - divX, newArea.getMaxY()));

                                if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
                                        // LOGGER.debug("Now it exeeds the left border.. cut!");
                                        // And cut the left if it moved out of the area
                                        newArea = new Envelope(new Coordinate(maxAllowedExtend
                                                        .getMinX(), newArea.getMinY()), new Coordinate(
                                                        newArea.getMaxX(), newArea.getMaxY()));

                                        // LOGGER.debug("and fix aspect ratio");

                                        newArea = JTSUtil.fixAspectRatio(getVisibleRect(), newArea,
                                                        false);
                                }
                        }

                        // Exceeds to the left? move and maybe cut
                        if (newArea.getMinX() < maxAllowedExtend.getMinX()) {

                                // Move right..
                                final double divX = newArea.getMinX()
                                                - maxAllowedExtend.getMinX();
                                // LOGGER.debug("Moving area right by " + divX);

                                newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
                                                newArea.getMinY()), new Coordinate(newArea.getMaxX()
                                                - divX, newArea.getMaxY()));

                                if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
                                        // LOGGER.debug("Now it exeeds the right border.. cut!");
                                        // And cut the left if it moved out of the area
                                        newArea = new Envelope(new Coordinate(newArea.getMinX(),
                                                        newArea.getMinY()), new Coordinate(maxAllowedExtend
                                                        .getMaxX(), newArea.getMaxY()));

                                        // LOGGER.debug("and fix aspect ratio");

                                        newArea = JTSUtil.fixAspectRatio(getVisibleRect(), newArea,
                                                        false);
                                }
                        }
                }

                return newArea;
        }

        /**
         * Should be called when the {@link JMapPane} is not needed no more to help
         * the GarbageCollector
         * 
         * Removes all {@link JMapPaneListener}s that are registered
         * 
         * @author <a href="mailto:[email protected]">Stefan Alfons
         *         Kr&uuml;ger</a>
         */
        public void dispose() {
                if (isDisposed())
                        return;

                setPainting(false);

                resizeTimer.stop();
                startRenderThreadsTimer.stop();

                disposed = true;

                if (bgExecuter != null) {
                        bgExecuter.cancelTask();
                        bgExecuter.dispose();
                }

                if (localExecuter != null) {
                        int i = 0;
                        localExecuter.cancelTask();
                        while (i++ < 10 && localExecuter.isRunning()) {
                                try {
                                        Thread.sleep(100);
                                } catch (final InterruptedException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                }
                        }
                        if (localExecuter.isRunning()) {
                                System.out
                                                .println("BAD BAD BAD... still running the thread....");
                        }
                        localExecuter.dispose();
                }

                disposeImages();

                // LangUtil.gcTotal();

                // Alle mapPaneListener entfernen
                mapPaneListeners.clear();

                removeMouseMotionListener(zoomMapPaneMouseListener);
                removeMouseListener(zoomMapPaneMouseListener);

                if (localContext != null)
                        getContext().clearLayerList();
                if (bgContext != null)
                        getBgContext().clearLayerList();

                removeAll();
        }

        /**
         * Draws a rectangle in XOR mode from the origin at {@link #startPos} to the
         * given point. All in screen coordinates.
         */
        protected void drawRectangle(final Graphics graphics, final Point startPos,
                        final Point e) {

                if (!isWellDefined())
                        return;

                // undraw last box/draw new box
                final int left = Math.min(startPos.x, e.x);
                final int right = Math.max(startPos.x, e.x);
                final int top = Math.max(startPos.y, e.y);
                final int bottom = Math.min(startPos.y, e.y);
                final int width = right - left;
                final int height = top - bottom;

                if (width == 0 && height == 0)
                        return;

                graphics.setXORMode(Color.WHITE);
                graphics.drawRect(left, bottom, width, height);
        }

        /**
         * Diretly paints scaled preview into the {@link SelectableXMapPane}. Used
         * to give the user something to look at while we are rendering. Method
         * should be called after {@link #setMapArea(Envelope)} has been set to the
         * new mapArea and transform has been reset.<br>
         * 
         * @param g
         *            Graphics2D to paint the preview into
         * 
         * @param state
         *            Max be {@link #ZOOM_IN} or {@link #ZOOM_OUT}
         */
        protected boolean drawScaledPreviewImage_Zoom(final Graphics2D graphics) {

//              if (1 == 1)return false;
                
                if (quickPreviewHint == 0)
                        return false;

                graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
                                RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
                graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                                RenderingHints.VALUE_ANTIALIAS_OFF);
                graphics.setRenderingHint(RenderingHints.KEY_RENDERING,
                                RenderingHints.VALUE_RENDER_SPEED);

                if (oldMapArea == null)
                        return false;

                final Rectangle visibleArea = getVisibleRect();

                // Calculate the oldMapArea in the current WindowCoordinates:
                final Envelope oldMapWindow = tranformGeoToWindow(oldMapArea.getMinX(),
                                oldMapArea.getMinY(), oldMapArea.getMaxX(), oldMapArea
                                                .getMaxY());

                final int xx1 = (int) Math.round(oldMapWindow.getMinX());
                final int yy1 = (int) Math.round(oldMapWindow.getMinY());
                final int xx2 = (int) Math.round(oldMapWindow.getMaxX());
                final int yy2 = (int) Math.round(oldMapWindow.getMaxY());

                graphics.drawImage(getPreFinalImage(), xx1, yy1, xx2, yy2,
                                (int) visibleArea.getMinX(), (int) visibleArea.getMinY(),
                                (int) visibleArea.getMaxX(), (int) visibleArea.getMaxY(),
                                getMapBackgroundColor(), null);

                final Rectangle painedArea = new Rectangle(xx1, yy1, xx2 - xx1, yy2
                                - yy1);

                SwingUtil.clearAround(graphics, painedArea, visibleArea);

                addGadgets(graphics, true);

                quickPreviewHint = 0;

                repaintTimer.restart();

                graphics.dispose();

                // Something has been drawn
                return true;
        }

        public MapContext getBgContext() {
                return bgContext;
        }

        /**
         * Lazyly initializes a {@link BufferedImage} for the background renderer.
         */
        private Image getBgImage() {
                //
                // if (bgImage == null) {
                // bgImage = createImage(getBounds().width, getBounds().height);
                // }

                return bgImage;
        }

        public MapContext getContext() {
                if (localContext == null) {
                        setLocalContext(new DefaultMapContext());
                }
                return localContext;
        }

        private BufferedImage getFinalImage() {
                //
                if (finalImage == null) {
                        // Rectangle curPaintArea = getVisibleRect();
                        finalImage = new BufferedImage(getVisibleRect().width,
                                        getVisibleRect().height, IMAGETYPE);

                        requestStartRendering();
                }
                return finalImage;
        }

        public RenderingHints getJava2dHints() {
                return java2dHints;
        }

        /**
         * Lazyly initializes a {@link BufferedImage} for the background renderer.
         */
        private BufferedImage getLocalImage() {

                if (localImage == null) {
                        localImage = new BufferedImage(getVisibleRect().width,
                                        getVisibleRect().height, IMAGETYPE_withAlpha);
                }

                return localImage;
        }

        /**
         * Returns a copy of the mapArea
         * 
         * @return
         */
        public ReferencedEnvelope getMapArea() {
                if (mapArea == null) {
                        ReferencedEnvelope mapArea_ = null;
                        try {
                                mapArea_ = localContext.getLayerBounds();
                        } catch (final IOException e) {
                                LOGGER.warn("context.getLayerBounds()", e);
                        }

                        if (mapArea_ != null) {
                                mapImageInvalid = true; /* note we need to redraw */
                                // setMapArea(mapArea_); // results in a loop
                                mapArea = bestAllowedMapArea(mapArea_);
                        }
                }

                if (mapArea == null)
                        return null;

                // TODO is needed at all, this should go to setMapArea maybe
                if (localContext.getCoordinateReferenceSystem() == null)
                        try {
                                localContext.setCoordinateReferenceSystem(GeoImportUtil
                                                .getDefaultCRS());
                        } catch (Exception e) {
                                throw new RuntimeException("setting context CRS:", e);
                        }

                return new ReferencedEnvelope(mapArea, localContext
                                .getCoordinateReferenceSystem());
        }

        /**
         * Returns the background {@link Color} of the map pane. Default is white.
         **/
        public Color getMapBackgroundColor() {
                return mapBackgroundColor;
        }

        /**
         * Get the BufferedImage to use as a flaoting icon in the lower right
         * corner.
         * 
         * @return <code>null</code> if the feature is deactivated.
         */
        public BufferedImage getMapImage() {
                return mapImage;
        }

        /**
         * Returns the evelope of the viewable area. The JMapPane will never show
         * anything outside of this extend. If this has been set to
         * <code>null</code> via {@link #setMaxExtend(Envelope)}, it tries to return
         * quickly the context's bounds. It it takes to long to determine the
         * context bounds, <code>null</code> is returned.
         * 
         * @param maxExtend
         *            <code>null</code> to not have this restriction.
         */

        public Envelope getMaxExtend() {
                if (maxExtend == null) {
                        final ReferencedEnvelope layerBounds = GTUtil
                                        .getVisibleLayoutBounds(localContext);
                        if (layerBounds == null) {
                                // TODO Last fallback could be the CRS valid area
                                return null;
                        }

                        // Kartenbereich um 10% vergroessern
                        return JTSUtil.fixAspectRatio(getVisibleRect(), JTSUtil
                                        .expandEnvelope(layerBounds, 0.1), true);
                }
                return maxExtend;
        }

        /**
         * Retuns the maximum allowed zoom scale. This is the smaller number value
         * of the two. Defaults to {@link Double}.MIN_VALUE
         * 
         * @author <a href="mailto:[email protected]">Stefan Alfons
         *         Kr&uuml;ger</a>
         */
        public Double getMaxZoomScale() {
                return maxZoomScale;
        }

        /**
         * Retuns the minimum allowed zoom scale. This is the bigger number value of
         * the two. Defaults to {@link Double}.MAX_VALUE
         * 
         * @author <a href="mailto:[email protected]">Stefan Alfons
         *         Kr&uuml;ger</a>
         */
        public Double getMinZoomScale() {
                return minZoomScale;
        }

        private Image getPreFinalImage() {
                // if (preFinalImage == null) {
                //                      
                // // Rectangle curPaintArea = getVisibleRect();
                // // preFinalImage = new BufferedImage(curPaintArea.width,
                // // curPaintArea.height, BufferedImage.TYPE_INT_RGB);
                //                      
                // preFinalImage = createImage(getBounds().width, getBounds().height);
                //
                // requestStartRendering();
                // }
                return preFinalImage;
        }

        public Map<Object, Object> getRendererHints() {
                // Clear label cache
                labelCache.clear();
                rendererHints.put(StreamingRenderer.LABEL_CACHE_KEY, labelCache);

                return rendererHints;
        }

        /**
         * Liefert eine affine Transformation, um von den Fenster-Koordinaten in die
         * Karten-Koordinaten (Lat/Lon) umzurechnen.
         * 
         * @return eine Kopie der aktuellen Transformation; <code>null</code> wenn
         *         noch keine Karte angezeigt wird
         */
        public AffineTransform getScreenToWorld() {
                if (screenToWorld == null)
                        resetTransforms();
                // nur Kopie der Transformation zurueckgeben!
                if (screenToWorld == null)
                        return null;
                return new AffineTransform(screenToWorld);
        }

        public int getState() {
                return state;
        }

        /**
         * Liefert den statisch eingestellten Cursor, der unabhaengig von der
         * eingestellten MapPane-Aktion (Zoom, Auswahl, ...) verwendet wird.
         * 
         * @return {@code null}, wenn kein statischer Cursor verwendet, sondern der
         *         Cursor automatisch je nach MapPane-Aktion eingestellt wird.
         */
        public Cursor getStaticCursor() {
                return this.staticCursor;
        }

        public AffineTransform getWorldToScreenTransform() {
                if (worldToScreen == null) {
                        resetTransforms();
                }
                // nur Kopie der Transformation zurueckgeben!
                return new AffineTransform(worldToScreen);
        }

        /**
         * A flag indicating if dispose() has already been called. If true, then
         * further use of this {@link SelectableXMapPane} is undefined.
         */
        private boolean isDisposed() {
                return disposed;
        }

        /**
         * Returns whether a layer is regarded or ignored on {@link #SELECT_TOP},
         * {@link #SELECT_ALL} and {@link #SELECT_ONE_FROM_TOP} actions. Returns
         * <code>true</code> if the selectability has not been defined.
         * 
         * @param layer
         *            a layer
         */
        public boolean isMapLayerSelectable(final MapLayer layer) {
                final Boolean selectable = mapLayerSelectable.get(layer);
                return selectable == null ? true : selectable;
        }

        /**
         * Return <code>true</code> if a CRS and a {@link #mapArea} are set and the
         * {@link XMapPane} is visible and has bounds set.
         */
        public boolean isWellDefined() {

                try {

                        if (getContext() == null)
                                return false;
                        if (getContext().getLayerCount() <= 0)
                                return false;
                        if (getMapArea() == null)
                                return false;
                        if (getBounds().getWidth() == 0)
                                return false;
                        if (getBounds().getHeight() == 0)
                                return false;
                } catch (final Exception e) {
                        return false;
                }
                return true;
        }

        public void mouseDragged(final Point startPos, final Point lastPos,
                        final MouseEvent event) {

                if ((getState() == XMapPane.PAN)
                                || ((event.getModifiersEx() & InputEvent.BUTTON3_DOWN_MASK) != 0)) {

                        if (getCursor() != SwingUtil.PANNING_CURSOR) {
                                setCursor(SwingUtil.PANNING_CURSOR);

                                // While panning, we deactivate the rendering. So the tasts are
                                // ready to start when the panning os done.
                                if (bgExecuter != null)
                                        bgExecuter.cancelTask();
                                if (localExecuter != null)
                                        localExecuter.cancelTask();
                        }

                        if (lastPos.x > 0 && lastPos.y > 0) {
                                final int dx = event.getX() - lastPos.x;
                                final int dy = event.getY() - lastPos.y;

                                // TODO Stop dragging when the drag would not be valid...
                                // boolean dragValid = true;
                                // // check if this panning results in a valid mapArea
                                // {
                                // Rectangle winBounds = xMapPane.getBounds();
                                // winBounds.translate(xMapPane.imageOrigin.x,
                                // -xMapPane.imageOrigin.y);
                                // Envelope newMapAreaBefore = xMapPane.tranformWindowToGeo(
                                // winBounds.x, winBounds.y, winBounds.x
                                // + winBounds.width, winBounds.y
                                // + winBounds.height);
                                //                                      
                                //
                                // winBounds = xMapPane.getBounds();
                                // Point testIng = new Point(xMapPane.imageOrigin);
                                // testIng.translate(dx, dy);
                                // winBounds.translate(testIng.x, -testIng.y);
                                // Envelope newMapAreaAfter = xMapPane.tranformWindowToGeo(
                                // winBounds.x, winBounds.y, winBounds.x
                                // + winBounds.width, winBounds.y
                                // + winBounds.height);
                                //
                                // // If the last drag doesn't change the MapArea anymore cancel
                                // it.
                                // if (xMapPane.bestAllowedMapArea(newMapAreaAfter).equals(
                                // xMapPane.bestAllowedMapArea(newMapAreaBefore))){
                                // dragValid = false;
                                // return;
                                // }
                                // }

                                imageOrigin.translate(dx, dy);
                                updateFinalImage();
                                repaint();
                        }

                } else if ((getState() == XMapPane.ZOOM_IN)
                                || (getState() == XMapPane.ZOOM_OUT)
                                || (getState() == XMapPane.SELECT_ALL)
                                || (getState() == XMapPane.SELECT_TOP)
                // || (getState() == XMapPane.SELECT_ONE_FROM_TOP)
                ) {
                        final Graphics graphics = getGraphics();

                        drawRectangle(graphics, startPos, event.getPoint());

                        if ((lastPos.x > 0) && (lastPos.y > 0)) {
                                drawRectangle(graphics, startPos, lastPos);
                        }

                        graphics.dispose();

                }

        }

        /**
         * Called by the {@link RenderingExecutor} when rendering was cancelled.
         */
        public void onRenderingCancelled() {
                repaintTimer.stop();
                LOGGER.debug("Rendering cancelled");
        }

        /**
         * Called by the {@link RenderingExecutor} when rendering has been
         * completed.
         */
        public void onRenderingCompleted() {
                repaintTimer.stop();
                updateFinalImage();
                repaint();
                if (renderingErrors.size() > 0)
                        renderingErrors.remove(0);
        }

        /**
         * Called by the {@linkplain XMapPane.RenderingTask} when rendering failed.
         * Publishes a {@linkplain MapPaneEvent} of type {@code
         * MapPaneEvent.Type.RENDERING_STOPPED} to listeners.
         * 
         * @param renderingError
         *            The error that occured during rendering
         * 
         * @see MapPaneListener#onRenderingStopped(org.geotools.swing.event.MapPaneEvent)
         */
        public void onRenderingFailed(final Exception renderingError) {
                this.renderingErrors.add(renderingError);
                if (renderingErrors.size() > 3)
                        renderingErrors.remove(0);
                repaintTimer.stop();
                LOGGER.warn("Rendering failed", renderingError);
                updateFinalImage();
                repaint();

        }

        public void onRenderingPending() {
                // LOGGER.debug("Pending rendering updates the preview...");
                updateFinalImage();
                repaint();
        }

        @Override
        protected void paintComponent(final Graphics g) {
                if (!acceptsRepaintCalls)
                        return;

                // Maybe update the cursor and maybe stop the repainting timer
                updateCursor();

                // super.paintComponent(g); // candidate for removal

                boolean paintedSomething = false;

                if (mapImageInvalid) { /* if the map changed then redraw */

                        mapImageInvalid = false; // Reset for next round

                        // If the new mapArea and the oldMapArea intersect, we can draw some
                        // quick scaled preview to make the user feel that something is
                        // happening.
                        if (mapAreaChanged && oldMapArea != null
                                        && getMapArea().intersects(oldMapArea)
                                        & !getMapArea().equals(oldMapArea)) {

                                mapAreaChanged = false;

                                if (getMapArea().covers(oldMapArea)) {
                                        setQuickPreviewHint(ZOOM_OUT);
                                        paintedSomething = drawScaledPreviewImage_Zoom((Graphics2D) g);
                                } else if (oldMapArea.covers(getMapArea())) {
                                        setQuickPreviewHint(ZOOM_IN);
                                        paintedSomething = drawScaledPreviewImage_Zoom((Graphics2D) g);
                                }

                        }

                        if (paneResized) {
                                paneResized = false;
                                disposeImages();
                        }

                        // Start the Threads and Timers to render the image
                        requestStartRendering();

                }

                if (!paintedSomething) {

                        g.drawImage(getFinalImage(), 0, 0, null);

                        g.dispose(); // cand. for removal

                        paintedSomething = true; // cand. for removal
                }

        }

        /**
         * Heavily works on releasing all resources related to the four
         * {@link Image}s used to cache the results of the different renderers.<br>
         * In November 2009 i had some memory leaking problems with {@link XMapPane}
         * . The resources of the buffered images were never released. It seem to be
         * important to call the GC right after flushing the images.<br>
         * Hence this method may take a while, because it calls the GC up to four
         * times.
         */
        private void disposeImages() {

                // System.out.println("vorher = "
                // + new MbDecimalFormatter().format(LangUtil.gcTotal()));
                // bi.flush();
                // return bi = null;
                // System.out.println("nacher = "
                // + new MbDecimalFormatter().format(LangUtil.gcTotal()));
                //
                // System.out.println("\n");

                if (preFinalImage != null) {
                        preFinalImage.flush();
                        preFinalImage = null;
                        LangUtil.gc();
                }
                if (finalImage != null) {
                        finalImage.flush();
                        finalImage = null;
                        LangUtil.gc();
                }
                if (localImage != null) {
                        localImage.flush();
                        localImage = null;
                        LangUtil.gc();
                }
                if (bgImage != null) {
                        bgImage.flush();
                        bgImage = null;
                        LangUtil.gc();
                }

        }

        /**
         * Performs a {@value #PAN} action. During panning, the displacement is
         * stored in {@link #imageOrigin} object. Calling {@link #performPan()} will
         * reset the offset and call {@link #setMapArea(Envelope)}.
         */
        public void performPan() {

                Rectangle winBounds = getVisibleRect();
                
                winBounds.translate(-imageOrigin.x, -imageOrigin.y);
                final Envelope newMapArea = tranformWindowToGeo(winBounds.x,
                                winBounds.y, winBounds.x + winBounds.width, winBounds.y
                                                + winBounds.height);

                imageOrigin.x = 0;
                imageOrigin.y = 0;

                if (!setMapArea(newMapArea)) {
                        /**
                         * If setMapArea returns true, the finalImage is updated anyways.
                         * This if-case exists to ensure that we repaint a correct image
                         * even if the new panning area has been denied.
                         */
                        updateFinalImage();
                        repaint();
                }

                if (getCursor() == SwingUtil.PANNING_CURSOR)
                        setCursor(SwingUtil.PAN_CURSOR);
        }

        //
        // /**
        // * Nuetzlich wenn die Componente gedruckt (z.B. wenn ein Screenshot
        // gemacht
        // * wird) wird. Dann werden wird der Hintergrund auf WEISS gesetzt.
        // *
        // * @author <a href="mailto:[email protected]">Stefan Alfons
        // * Kr&uuml;ger</a>
        // */
        // @Override
        // public void print(final Graphics g) {
        // final Color orig = getBackground();
        // setBackground(Color.WHITE);
        //
        // // wrap in try/finally so that we always restore the state
        // try {
        // super.print(g);
        // } finally {
        // setBackground(orig);
        // }
        // }

        /**
         * Entfernt einen Listener von der Map.
         * 
         * @param l
         *            zu entfernender Listener
         */
        public void removeMapPaneListener(final JMapPaneListener l) {
                mapPaneListeners.remove(l);
        }

        /**
         * Cancels all running renderers and sets the flag to start new ones. <br>
         * 
         * @see #startRenderThreadsTimer
         */
        private void requestStartRendering() {
                if (bgExecuter != null)
                        bgExecuter.cancelTask();
                if (localExecuter != null)
                        localExecuter.cancelTask();
                requestStartRendering = true;

        }

        //
        // /**
        // * Berechnet die Transformation zwischen Fenster- und Karten-Koordinaten
        // * neu.
        // */
        // protected void resetTransforms() {
        // if (getMapArea() == null || getWidth() == 0 || getHeight() == 0)
        // return;
        //
        // // We store the last Transform
        // oldScreenToWorld = screenToWorld;
        //
        // this.screenToWorld = new AffineTransform(
        // // Genauso wie die Fenster-Koordinaten, werden die Longitude-Koordinaten
        // // nach rechts (Osten) hin groesser
        // // --> positive Verschiebung
        // getMapArea().getWidth() / getWidth(),
        // // keine Verzerrung
        // 0.0, 0.0,
        // // Waehrend die Fenster-Koordinaten nach unten hin groesser
        // // werden,
        // // werden Latitude-Koordinaten nach Sueden hin keiner
        // // --> negative Verschiebung
        // -getMapArea().getHeight() / getHeight(),
        // // Die Longitude-Koordinaten werden nach Osten hin groesser
        // // --> obere linke Ecke des Fensters hat also den Minimalwert
        // getMapArea().getMinX(),
        // // Die Latitude-Koordinaten werden nach Norden hin groesser
        // // --> obere linke Ecke des Fensters hat also den Maximalwert
        // getMapArea().getMaxY());
        //
        // try {
        // this.worldToScreen = screenToWorld.createInverse();
        // } catch (final NoninvertibleTransformException e) {
        // LOGGER.error(e);
        // }
        // }

        /**
         * Calculate the affine transforms used to convert between world and pixel
         * coordinates. The calculations here are very basic and assume a cartesian
         * reference system.
         * <p>
         * Tne transform is calculated such that {@code envelope} will be centred in
         * the display
         * 
         * @param envelope
         *            the current map extent (world coordinates)
         * @param paintArea
         *            the current map pane extent (screen units)
         */
        private void resetTransforms() {
                ReferencedEnvelope refMapEnv = new ReferencedEnvelope(mapArea,
                                getContext().getCoordinateReferenceSystem());

                Rectangle paintArea = getVisibleRect(); // NOT USE GET BOUNDS!
                
                //        
                // double xscale = paintArea.getWidth() / refEnv.getWidth();
                // double yscale = paintArea.getHeight() / refEnv.getHeight();
                //
                // double scale = Math.min(xscale, yscale);
                //
                // double xoff = refEnv.getMedian(0) * scale - paintArea.getCenterX();
                // double yoff = refEnv.getMedian(1) * scale + paintArea.getCenterY();

                worldToScreen = RendererUtilities.worldToScreenTransform(refMapEnv,
                                paintArea);

                // worldToScreen = new AffineTransform(scale, 0, 0, -scale, -xoff,
                // yoff);
                try {
                        screenToWorld = worldToScreen.createInverse();

                } catch (NoninvertibleTransformException ex) {
                        ex.printStackTrace();
                }
        }

        public void setBgContext(final MapContext context) {

                // Remove the default listener from the old context
                if (this.bgContext != null) {
                        this.bgContext.removeMapLayerListListener(bgContextListener);

                        // adding listener to all layers
                        for (final MapLayer mapLayer : bgContext.getLayers()) {
                                mapLayer.removeMapLayerListener(bgMapLayerListener);
                        }
                }

                this.bgContext = context;

                if (context != null) {
                        setMapArea(bgContext.getAreaOfInterest());

                        this.bgContext.addMapLayerListListener(bgContextListener);

                        // adding listener to all layers
                        for (final MapLayer mapLayer : bgContext.getLayers()) {
                                mapLayer.addMapLayerListener(bgMapLayerListener);
                        }
                }
                mapImageInvalid = true;
                repaint();
        }

        public void setJava2dHints(final RenderingHints java2dHints) {
                this.java2dHints = java2dHints;
        }

        /**
         * 
         * @param context
         */
        public void setLocalContext(final MapContext context) {
                // Remove the default listener from the old context
                if (this.localContext != null) {
                        this.localContext.removeMapLayerListListener(localContextListener);

                        // adding listener to all layers
                        for (final MapLayer mapLayer : localContext.getLayers()) {
                                mapLayer.removeMapLayerListener(localMapLayerListener);
                        }
                }

                this.localContext = context;

                if (context != null) {

                        setMapArea(localContext.getAreaOfInterest());

                        localRenderer.setContext(localContext);

                        this.localContext.addMapLayerListListener(localContextListener);

                        // adding listener to all layers
                        for (final MapLayer mapLayer : localContext.getLayers()) {
                                mapLayer.addMapLayerListener(localMapLayerListener);
                        }
                }

                mapImageInvalid = true;
                repaint();
        }

        /**
         * @param newMapArea
         * @return <code>true</code> if the mapArea has been changed and a repaint
         *         has been triggered.
         */
        public boolean setMapArea(final Envelope newMapArea) {

                if (newMapArea == null
                                || bestAllowedMapArea(newMapArea).equals(mapArea)) {
                        // No change.. no need to repaint
                        return false;
                }

                // Testing, whether NaN or Infinity are used in the newMapArea
                if (newMapArea.isNull() || Double.isInfinite(newMapArea.getMaxX())
                                || Double.isInfinite(newMapArea.getMaxY())
                                || Double.isInfinite(newMapArea.getMinX())
                                || Double.isInfinite(newMapArea.getMinY())) {
                        // No change.. ugly new values
                        LOGGER.warn("setMapArea has been called with newArea = "
                                        + newMapArea);
                        return false;
                }

                final Envelope candNew = bestAllowedMapArea(newMapArea);

                // Testing, whether the difference if just minimal
                if (mapArea != null) {
                        final double tolX = mapArea.getWidth() / 1000.;
                        final double tolY = mapArea.getHeight() / 1000.;
                        if ((candNew.getMinX() - tolX < mapArea.getMinX())
                                        && (mapArea.getMinX() < candNew.getMinX() + tolX)
                                        && (candNew.getMaxX() - tolX < mapArea.getMaxX())
                                        && (mapArea.getMaxX() < candNew.getMaxX() + tolX)

                                        && (candNew.getMinY() - tolY < mapArea.getMinY())
                                        && (mapArea.getMinY() < candNew.getMinY() + tolY)
                                        && (candNew.getMaxY() - tolY < mapArea.getMaxY())
                                        && (mapArea.getMaxY() < candNew.getMaxY() + tolY)

                        ) {
                                // The two mapAreas only differ my 1/1000th.. ignore

                                return false;
                        }
                }

                // New map are is accepted:
                oldMapArea = mapArea;
                mapArea = candNew;
                resetTransforms();

                if (localContext != null) {
                        localContext.setAreaOfInterest(mapArea, localContext
                                        .getCoordinateReferenceSystem());
                }
                if (bgContext != null) {
                        bgContext.setAreaOfInterest(mapArea, localContext
                                        .getCoordinateReferenceSystem());
                }
                mapImageInvalid = true;
                mapAreaChanged = true;
                repaint();

                LOGGER.debug("New maparea = " + mapArea);
                return true;
        }

        /**
         * Set the background color of the map.
         * 
         * @param if <code>null</code>, white is used.
         */
        public void setMapBackgroundColor(Color bgColor) {
                if (bgColor == null)
                        bgColor = Color.WHITE;
                this.mapBackgroundColor = bgColor;
        }

        /**
         * Set the BufferedImage to use as a flaoting icon in the lower right corner
         * 
         * @param mapImageIcon
         *            <code>null</code> is allowed and deactivates this icon.
         */
        public void setMapImage(final BufferedImage mapImage) {
                this.mapImage = mapImage;
        }

        /**
         * Sets whether a layer is regarded or ignored on {@link #SELECT_TOP},
         * {@link #SELECT_ALL} and {@link #SELECT_ONE_FROM_TOP} actions.
         * 
         * @param layer
         *            a layer
         * @param selectable
         *            if {@code false} the layer is ignored during the upper
         *            mentioned actions. If <code>null</code>, the default (true)
         *            will be used.
         */
        public void setMapLayerSelectable(final MapLayer layer,
                        final Boolean selectable) {
                if (selectable == null)
                        mapLayerSelectable.remove(layer);
                else
                        mapLayerSelectable.put(layer, selectable);
        }

        /**
         * Defines an evelope of the viwable area. The JMapPane will never show
         * anything outside of this extend.
         * 
         * @param maxExtend
         *            <code>null</code> to not have this restriction.
         */
        public void setMaxExtend(final Envelope maxExtend) {
                this.maxExtend = maxExtend;
        }

        /**
         * Set the maximum allowed zoom scale. This is the smaller number value of
         * the two. If <code>null</code> is passed, Double.MINVALUE are used which
         * mean there is no restriction.
         * 
         * @author <a href="mailto:[email protected]">Stefan Alfons
         *         Kr&uuml;ger</a>
         */
        public void setMaxZoomScale(final Double maxZoomScale) {
                this.maxZoomScale = maxZoomScale == null ? Double.MIN_VALUE
                                : maxZoomScale;
        }

        // /** Stored the time used for the last real rendering in ms. **/
        // private long lastRenderingDuration = Long.MAX_VALUE;

        /**
         * Set the minimum (nearest) allowed zoom scale. This is the bigger number
         * value of the two. If <code>null</code> is passed, Double.MAXVALUE are
         * used which mean there is no restriction.
         * 
         * 
         * @author <a href="mailto:[email protected]">Stefan Alfons
         *         Kr&uuml;ger</a>
         */
        public void setMinZoomScale(final Double minZoomScale) {
                this.minZoomScale = minZoomScale == null ? Double.MAX_VALUE
                                : minZoomScale;
        }

        /**
         * 
         * @param b
         */
        public void setPainting(final boolean b) {
                acceptsRepaintCalls = b;
        }

        // /**
        // * Returns in milli seconds the time the last rending of the
        // * {@link SelectableXMapPane} took. #Long.MAX_VALUE if the JMapPane has
        // not
        // * been rendered yet.
        // */
        // public long getLastRenderingDuration() {
        // return lastRenderingDuration;
        // }

        public void setQuickPreviewHint(final int quickPreviewHint) {
                this.quickPreviewHint = quickPreviewHint;

        }

        private void setRendererHints(final Map<Object, Object> rendererHints) {
                if (rendererHints != null)
                        this.rendererHints = rendererHints;
        }

        /**
         * Enables/Disables the ZOOM Mouse Listener. Upates the Cursor and stops the
         * repaint Timer if
         * 
         * @param state
         */
        public void setState(final int state) {
                this.state = state;

                zoomMapPaneMouseListener.setEnabled((state == ZOOM_IN
                                || state == ZOOM_OUT || state == PAN));

                // Je nach Aktion den Cursor umsetzen
                updateCursor();
        }

        /**
         * Standardmaessig wird der Cursor automatisch je nach MapPane-Aktion (Zoom,
         * Auswahl, ...) gesetzt. Mit dieser Methode kann ein statischer Cursor
         * gesetzt werden, der unabhaengig von der aktuellen MapPanes-Aktion
         * beibehalten wird. Um diesen statischen Cursor wieder zu entfernen, kann
         * {@code null} als Parameter uebergeben werden
         * 
         * @param cursor
         *            Cursor
         */
        public void setStaticCursor(final Cursor cursor) {
                this.staticCursor = cursor;
                if (cursor != null)
                        super.setCursor(cursor);
        }

        /**
         * Starts rendering on one or two threads
         */
        private void startRendering() {

                if (!isWellDefined())
                        return;

                if (bgExecuter != null) {
                        // Stop all renderers
                        bgExecuter.cancelTask();
                }

                if (localExecuter != null) {
                        localExecuter.cancelTask();
                }

                final Rectangle curPaintArea = getVisibleRect();

                /**
                 * We have to set new renderer
                 */

                if (getBgContext() != null) {
                        bgRenderer.setJava2DHints(getJava2dHints());
                        bgRenderer.setRendererHints(getRendererHints());

                        // bgExecuter = new RenderingExecutor();
                        // LOGGER.debug("starting bg renderer:");
                        // // /* System.out.println("rendering"); */
                        // final GTRenderer createGTRenderer = GTUtil.createGTRenderer(
                        // bgContext, getRendererHints());
                        // createGTRenderer.setJava2DHints(getJava2dHints());
                        // bgExecuter.submit(getBgContext().getAreaOfInterest(),
                        // curPaintArea,
                        // (Graphics2D) getBgImage().getGraphics(), createGTRenderer);
                }

                if (getContext() != null) {
                        // localExecuter = new RenderingExecutor(this, 150l);
                        // LOGGER.debug("starting local renderer:");

                        localRenderer.setJava2DHints(getJava2dHints());
                        localRenderer.setRendererHints(getRendererHints());

                        ReferencedEnvelope areaOfInterest = getMapArea();
                        final boolean submitted = localExecuter.submit(areaOfInterest,
                                        curPaintArea, (Graphics2D) getLocalImage().getGraphics(),
                                        localRenderer, getWorldToScreenTransform());
                        if (submitted)
                                repaintTimer.restart();
                        else
                                requestStartRendering = true; // Try to start rendering again in
                        // a moment
                }

                updateCursor();
        }

        /**
         * Transformiert einen Geo-Koordinaten-Bereich in Fenster-Koordinaten.
         * 
         * @param ox
         *            X-Koordinate der VON-Position
         * @param oy
         *            Y-Koordinate der VON-Position
         * @param px
         *            X-Koordinate der BIS-Position
         * @param py
         *            Y-Koordinate der BIS-Position
         * @param winToGeotransform
         *            Eine Window to Geo transform. If <code>null</code>,
         *            {@link #getScreenToWorld()} is used.
         */
        public Envelope tranformGeoToWindow(final double ox, final double oy,
                        final double px, final double py) {
                final AffineTransform at = getWorldToScreenTransform();
                Point2D geoO;
                // try {
                geoO = at.transform(new Point2D.Double(ox, oy), null);
                final Point2D geoP = at.transform(new Point2D.Double(px, py), null);
                return new Envelope(geoO.getX(), geoP.getX(), geoO.getY(), geoP.getY());
                // } catch (final NoninvertibleTransformException e) {
                // LOGGER.error(e);
                // return new Envelope(ox, oy, px, py);
                // }
        }

        /**
         * Transformiert einen Fenster-Koordinaten-Bereich in Geo-Koordinaten.
         * 
         * @param ox
         *            X-Koordinate der VON-Position
         * @param oy
         *            Y-Koordinate der VON-Position
         * @param px
         *            X-Koordinate der BIS-Position
         * @param py
         *            Y-Koordinate der BIS-Position
         */
        public Envelope tranformWindowToGeo(final int ox, final int oy,
                        final int px, final int py) {
                final AffineTransform at = getScreenToWorld();
                final Point2D geoO = at.transform(new Point2D.Double(ox, oy), null);
                final Point2D geoP = at.transform(new Point2D.Double(px, py), null);
                
                // Mmmmm... don't really understand why its x,x,y,y
//              return new Envelope(geoO.getX(), geoP.getX(), geoO.getY(), geoP.getY());
                return new Envelope( new Coordinate(geoO.getX(), geoO.getY()), new Coordinate(geoP.getX(), geoP.getY()));
        }

        /**
         * Will update the cursor. If all rendering is finished also stops the
         * {@link #repaintTimer}
         */
        public void updateCursor() {

                // if the renderers have stopped, also stop the timer that is updating
                // the final image
                if (bgExecuter != null && bgExecuter.isRunning()
                                || localExecuter != null && localExecuter.isRunning()) {
                        setCursor(WAIT_CURSOR);
                        return;
                } else {
                        // Allow one last rendering
                        if (repaintTimer.isRunning()) {
                                System.out.println("one last rendering....");
                                repaintTimer.stop();
                                updateFinalImage();
                                repaint();
                        }
                }

                // wenn manueller Cursor gesetzt ist, dann diesen verwenden (unabhaengig
                // von der aktuellen Aktion
                if (this.staticCursor != null) {
                        setCursor(staticCursor);
                        return;
                }
                if (getCursor() == SwingUtil.PANNING_CURSOR) {
                        // This cursor will reset itself
                        return;
                }

                // Set the cursor depending on what tool is in use...
                switch (state) {
                case SELECT_TOP:
                case SELECT_ONE_FROM_TOP:
                case SELECT_ALL:
                        setCursor(SwingUtil.CROSSHAIR_CURSOR);
                        break;
                case ZOOM_IN:
                        setCursor(SwingUtil.ZOOMIN_CURSOR);
                        break;
                case ZOOM_OUT:
                        setCursor(SwingUtil.ZOOMOUT_CURSOR);
                        break;
                case PAN:
                        setCursor(SwingUtil.PAN_CURSOR);
                        break;
                default:
                        setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
                        break;
                }
        }

        /**
         * The renderers are all rendering into their own {@link Image}s. This
         * method combines all images to one {@link #finalImage}. The
         * {@link #repaintTimer} is calling this method regularely to update the
         * {@link #finalImage} even if the renderers are still working.
         */
        synchronized protected Image updateFinalImage() {

                // Render the two map images first, into the preFinalImage
                if (bgExecuter != null) {
                        final Graphics2D preFinalG = (Graphics2D) getPreFinalImage()
                                        .getGraphics();
                        preFinalG.setBackground(getMapBackgroundColor());

                        preFinalG.drawImage(getBgImage(), 0, 0, getMapBackgroundColor(),
                                        null);

                        // // Draw the local layers image
                        preFinalG.drawImage(getLocalImage(), 0, 0, null);
                        preFinalG.dispose();

                } else {
                        preFinalImage = getLocalImage();
                }

                final Graphics2D finalG = getFinalImage().createGraphics();
                finalG.setBackground(getMapBackgroundColor());
                finalG.drawImage(getPreFinalImage(), imageOrigin.x, imageOrigin.y,
                                getMapBackgroundColor(), null);

                final int finalImageHeight = getFinalImage().getHeight(null);
                final int finalImageWidth = getFinalImage().getWidth(null);

                final Rectangle painedArea = new Rectangle(imageOrigin.x,
                                imageOrigin.y, finalImageWidth, finalImageHeight);
                SwingUtil.clearAround(finalG, painedArea, getVisibleRect());

                addGadgets(finalG, false);

                finalG.dispose();

                return finalImage;
        }

        /**
         * Paints some optional stuff into the given {@link Graphics2D}. Usually
         * called as the last layer when {@link #updateFinalImage()}
         * 
         * @param forceWait
         *            if <code>true</code>, a Wait-message will be painted even
         *            though the rendering threads may not yet have started. If
         *            <code>false</code>, it will only depend on
         *            {@link #localExecuter.isRunning} and #bgExecuter.isRunning
         */
        private void addGadgets(final Graphics2D graphics, boolean forceWait) {

                // Paint a logo to the bottom right if available
                if (mapImage != null) {
                        Rectangle visibleRect = getVisibleRect();
                        graphics.drawImage(mapImage, visibleRect.width
                                        - mapImage.getWidth() - 10, getVisibleRect().height
                                        - mapImage.getHeight() - 10, null);
                }

                int y = 17;

                // If the rendering process is still running, indicate this is the image
                if (forceWait || bgExecuter != null && bgExecuter.isRunning()
                                || localExecuter != null && localExecuter.isRunning()) {

                        y += 8;

                        final Color c = graphics.getColor();
                        graphics.setFont(waitFont);

                        graphics.setColor(getMapBackgroundColor());
                        graphics.drawString(waitMsg, 5, y);
                        graphics.setColor(getMapBackgroundColor());
                        graphics.drawString(waitMsg, 7, y + 2);
                        graphics.setColor(Color.BLACK);
                        graphics.drawString(waitMsg, 6, y + 1);

                        graphics.setColor(c);

                        y += 24;
                }

                if (renderingErrors != null) {

                        final Color c = graphics.getColor();
                        graphics.setFont(errorFont);

                        for (Exception ex : renderingErrors) {

                                if (ex instanceof java.lang.IllegalArgumentException
                                                && ex.getMessage().equals(
                                                                "Argument \"sourceCRS\" should not be null."))
                                        continue;

                                String errStr = ex.getLocalizedMessage();

                                graphics.setColor(Color.WHITE);
                                graphics.drawString(errStr, 5, y);
                                graphics.setColor(Color.RED);
                                graphics.drawString(errStr, 6, y + 1);

                                y += 19;
                        }

                        graphics.setColor(c);
                }

        }

        /**
         * Sets the {@link #mapArea} to best possibly present the given features. If
         * only one single point is given, the window is moved over the point.
         * 
         * @param features
         *            if <code>null</code> or size==0, the function doesn nothing.
         */
        public void zoomTo(
                        final FeatureCollection<SimpleFeatureType, SimpleFeature> features) {

                final CoordinateReferenceSystem mapCRS = getContext()
                                .getCoordinateReferenceSystem();
                final CoordinateReferenceSystem fCRS = features.getSchema()
                                .getGeometryDescriptor().getCoordinateReferenceSystem();

                double width = mapArea.getWidth();
                double height = mapArea.getHeight();
                final double ratio = height / width;

                if (features == null || features.size() == 0) {
                        // feature count == 0 Zoom to the full extend
                        return;
                } else if (features.size() == 1) {

                        // feature count == 1 Just move the window to the point and zoom 'a
                        // bit'
                        final SimpleFeature singleFeature = features.iterator().next();

                        if (((Geometry) singleFeature.getDefaultGeometry())
                                        .getCoordinates().length > 1) {
                                // System.out.println("Zoomed to only pne poylgon");
                                // Poly
                                // TODO max width vs. height
                                width = features.getBounds().getWidth() * 3;
                                height = ratio * width;
                        } else {
                                // System.out.println("Zoomed in a bit becasue only one point");
                                // width *= .9;
                                // height *= .9;
                        }

                        Coordinate centre = features.getBounds().centre();
                        if (!mapCRS.equals(fCRS)) {
                                // only to calculations if the CRS differ
                                try {
                                        MathTransform fToMap;
                                        fToMap = CRS.findMathTransform(fCRS, mapCRS);
                                        // centre is transformed to the mapCRS
                                        centre = JTS.transform(centre, null, fToMap);
                                } catch (final FactoryException e) {
                                        LOGGER.error("Looking for a Math transform", e);
                                } catch (final TransformException e) {
                                        LOGGER.error("Looking for a Math transform", e);
                                }
                        }

                        final Coordinate newLeftBottom = new Coordinate(centre.x - width
                                        / 2., centre.y - height / 2.);
                        final Coordinate newTopRight = new Coordinate(
                                        centre.x + width / 2., centre.y + height / 2.);

                        final Envelope newMapArea = new Envelope(newLeftBottom, newTopRight);

                        setMapArea(newMapArea);

                } else {
                        final ReferencedEnvelope fBounds = features.getBounds();

                        Envelope bounds;
                        if (!mapCRS.equals(fCRS)) {
                                bounds = JTSUtil.transformEnvelope(fBounds, fCRS, mapCRS);
                        } else {
                                bounds = fBounds;
                        }
                        // BB umrechnen von Layer-CRS in Map-CRS

                        // Expand a bit
                        bounds.expandBy(bounds.getWidth() / 6., bounds.getHeight() / 6.);

                        setMapArea(bounds);
                }
        }

        /**
         * Zooms towards a point.
         * 
         * @param center
         *            position in window coordinates
         * @param zoomFactor
         *            > 1 for zoom in, < 1 for zoom out. Default is 1.33
         */
        public void zoomTo(final Point center) {
                zoomTo(center, null);
        }

        /**
         * Zooms towards a point.
         * 
         * @param center
         *            position in window coordinates
         * @param zoomFaktor
         *            > 1 for zoom in, < 1 for zoom out. Default is 1.33.
         */
        public void zoomTo(Point center, Double zoomFaktor) {
                if (zoomFaktor == null || zoomFaktor == 0.)
                        zoomFaktor = 2.;

                final Point2D gcenter = getScreenToWorld().transform(center, null);
                center = null;

                if (Double.isNaN(gcenter.getX()) || Double.isNaN(gcenter.getY())
                                || Double.isInfinite(gcenter.getX())
                                || Double.isInfinite(gcenter.getY())

                ) {
                        // Not inside valid CRS area! cancel
                        return;
                }

                final Envelope mapArea = getMapArea();

                final Envelope newMapArea = new Envelope(mapArea);
                newMapArea.expandBy((mapArea.getWidth() * zoomFaktor - mapArea
                                .getWidth()) / 2., (mapArea.getHeight() * zoomFaktor - mapArea
                                .getHeight()) / 2.);
                
// TODO we actually want that
//              // Move the newMapArea above the new center
//              newMapArea.translate(gcenter.getX() - mapArea.centre().x, gcenter
//                              .getY()
//                              - mapArea.centre().y);

                setMapArea(newMapArea);
        }

}